1. import java.util.*;
   
2. class ArrayDemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 String[] arr = {"abc","cc","kkk"};
   
7.                 List<String>list = Arrays.asList(arr);
   
8.                 sop(list);
   
9.                 //int[] num = {2,3,5};//基本数据类型
   
10.                 //List<int[]> li=Arrays.asList(num);
    
11.                 Integer[] num = {2,3,5};//对象
    
12.                 List li = Arrays.asList(num);
    
13.         }
    
14.         public static void sop(Object obj)
    
15.         {
    
16.                 System.out.println(obj);
    
17.         }
    
18. }

复制代码

我想问一下                //int[] num = {2,3,5};//基本数据类型
                //List<int[]> li=Arrays.asList(num);
                Integer[] num = {2,3,5};//对象
                List li = Arrays.asList(num);
这两种写法运行结果是一样的，但是基本数据类型转换成集合和对象转换成集合这一块还是有点疑惑，List<int[]> li=Arrays.asList(num);这里加泛型，而这里List li = Arrays.asList(num);
没有加上泛型又是为啥？还有//List<int[]> li=Arrays.asList(num);和List li = Arrays.asList(num);
写的也不一样，实在是不懂，还请帮助解释一下。先谢谢了。

import java.util.*;
class Test1
{
        public static void main(String[] args)
        {
                        String[] arr = {"abc","cc","kkk"};
                List<String>list = Arrays.asList(arr);
                sop(list);
                int[] num1 = {2,3,5};//基本数据类型
                                //这个是把数组作为对象存储进集合
                List<int[]> list1=Arrays.asList(num1);
                            sop(list1);
                Integer[] num2 = {2,3,5};//打印出的是数组的地址值
                                //把Integer作为对象存储
                List<Integer> list2 = Arrays.asList(num2);
                                sop(list2);//打印的是Integer对象的集合[2,3,5]
    }
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
}

首先，指出你的理解错误
  //int[] num = {2,3,5};//基本数据类型
                //List<int[]> li=Arrays.asList(num);
                 Integer[] num = {2,3,5};//对象
                List li = Arrays.asList(num);
两者运行结果是一样的。
再者，没有基本数据对象转换成集合这种说法，因为集合只能存储引用类型的数据对象。
下面代码是给你的解释，太详细了（我自己都佩服自己了，哈哈，自恋下），不懂再问

1. /*
   
2.                  * 首先建议你看一下帮助文档中Arrays.asList()的解释
   
3.                  * 应该注意到，这是一个泛型方法而且其参数是可变参数，而可变参数的实现就是基于JDK1.4中的数组
   
4.                  * 下面再看这集中情况
   
5.                  */
   
6.                
   
7.                   String[] arr = {"abc","cc","kkk"};
   
8.                   /*
   
9.                    * 当你为List加上泛型后，也就是告诉编译器asList()方法中的参数是一个
   
10.                    * String类型的可变参数，也就是说asList()方法中的参数可以是一个String类型的字符串，也可以是N个
    
11.                    * 现在你没有给它多个字符串，而是给它一个String类型的数组，编译器将按照JDk1.4的语法编译
    
12.                    * 把数组拆成单个字符串，放入集合中
    
13.                    */
    
14.           List<String>list = Arrays.asList(arr);
    
15.           sop(list);
    
16.           /*
    
17.            * 你给List指定的泛型是int[]的数组，相当于一个Object,也就是说asList方法中的参数
    
18.            * 可以是一个int[]，也可以是N个int[]，当你用一个int[]类型的对象作为参数时
    
19.            * 编译器会把它看成可变参数，按照JDk5.0的语法去编译,把num1当做一个Object存入集合
    
20.            * 也就是说List中只有一个int[]的引用，它其实是一个地址值
    
21.            * 所以打印的是数组的哈希值
    
22.            */
    
23.           int[] num1 = {2,3,5};
    
24.          List<int[]> list1=Arrays.asList(num1);
    
25.                       sop(list1);
    
26.      
    
27.            //看了第一个的解释，这个也就不难理解了           
    
28.           Integer[] num2 = {2,3,5};
    
29.          List list2 = Arrays.asList(num2);//这一行的泛型可以加，也可以不加，运行结果一样
    
30.                           sop(list2);

复制代码