int[] arr = new int[]{1,2};

String[] arr1 = new String[]{"1","2"};

输出
[[I@b5dac4]
[1, 2]

听张老师没听懂，哪位大哥带着泛型讲讲
public static <T> List<T> asList(T... a)

这个参数到底怎么个传递方法才能使返回的不一致

asList(T... a) 就是将数组变成list集合
我真心没明白你的给出的代码段是干什么呢？贴上来的目的是什么？
我猜你可能想看看用aslist把基本数据类型数组转换成List列表后的情况和直接转换成字符串的区别吧？
对于aslist的调用很简单：给你个示例你可以看看
这四种情况的打印结果分别是
[2, 4, 5]
list=[afg, ccc, ggg]
li=[[I@7b7035c6]注意打印结果只有一个，而且是个地址
lii=[2, 5, 4]
之所以出现这样的原因是：
如果数组中的元素都是对象，那么变成集合时，数组中的元素
都直接转换成集合中的元素
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

1. int[] arr = {2,4,5};
   
2. System.out.println(Arrays.toString(arr));
   
3. //基本类型数组用toString转换成字符串
   
4. 
   
5. String[] arr = {"afg","ccc","ggg"};
   
6. List<String> list = Arrays.asList(arr);
   
7. //字符数组用asList转换成列表
   
8. 
   
9. int[] nums = {2,5,4};
   
10. List<int[]> li = Arrays.asList(nums);
    
11. //基本数据类型用asList转换成List列表
    
12. 
    
13. Integer[] numss = {2,5,4};//涉及到自动装箱
    
14. List<Integer> lii = Arrays.asList(numss);
    
15. //Integer类型数组用asList转换成List列表

复制代码

关于你的第二个问题“public static <T> List<T> asList(T... a) ”是什么？我的确不明白你想表达的什么意思。
下面给出一些泛型的用法，也是毕老师视频上的。你可以借鉴下

1. /*
   
2. //<font color="red">类上定义泛型</font>
   
3. class Demo<T>
   
4. {
   
5.         public void show(T t)
   
6.         {
   
7.                 System.out.println("show:"+t);
   
8.         }
   
9.         public void print(T t)
   
10.         {
    
11.                 System.out.println("print:"+t);
    
12.         }
    
13. }
    
14. */
    
15. //泛型类定义的泛型，在整个类中有效，如果被方法使用
    
16. //那么泛型类的对象明确要操作的具体类型后，所有需要操作的类型就已经固定了
    
17. //为了让不同方法可以操作不同类型，而且类型还不确定，可以将泛型定义在方法上。
    
18. 
    
19. /*
    
20. //<font color="red">方法上定义泛型</font>
    
21. class Demo
    
22. {
    
23.         public <T> void show(T t)
    
24.         {
    
25.                 System.out.println("show:"+t);
    
26.         }
    
27.         public <Q> void print(Q q)
    
28.         {
    
29.                 System.out.println("print:"+q);
    
30.         }
    
31. }
    
32. */
    
33. 
    
34. //<font color="red">类上定义泛型，同时方法上也定义泛型</font>
    
35. /*
    
36. 特殊之处：
    
37. 静态方法不可以访问类上定义的泛型
    
38. 如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
    
39. */
    
40. //泛型定义在类上和方法上
    
41. class Demo<T>
    
42. {
    
43.         public void show(T t)
    
44.         {
    
45.                 System.out.println("show:"+t);
    
46.         }
    
47.         public <Q> void print(Q q)
    
48.         {
    
49.                 System.out.println("print:"+q);
    
50.         }
    
51. 
    
52.         //public static void method(T t)
    
53.         //{
    
54.                 //System.out.println("method:"+t);
    
55.         //}//无法从静态上下文中引用非静态 类型变量 T，因为静态先于对象存在，而T不确定，导致编译失败
    
56. 
    
57.         public static <W> void method(W w)//泛型放到返回值类型前，修饰符后
    
58.         {
    
59.                 System.out.println("method:"+w);
    
60.         }
    
61. }

复制代码

gerenvip 发表于 2013-4-19 21:22
asList(T... a) 就是将数组变成list集合
我真心没明白你的给出的代码段是干什么呢？贴上来的目的是什么？
...

我的问题是为什么使用int[]的时候就返回一个地址，而没有返回像String[]的哪样，原理是什么

王大斌 发表于 2013-4-19 23:06
我的问题是为什么使用int[]的时候就返回一个地址，而没有返回像String[]的哪样，原理是什么
...

原理是这样的：
如果数组中的元素都是对象，那么变成集合时，数组中的元素， 都直接转换成集合中的元素
例如
13.Integer[] numss = {2,5,4};数组中存储的是Integer类型的对象，所以转换成list后，原来的对象就变成了list中的元素了

而如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
如：int[] nums = {2,5,4};
List<int[]> li = Arrays.asList(nums);
数组中存放的是基本和数据类型int型，那么转后后，整个数组num就会变成list集合中的一个元素，这时list集合中就只有一个元素，那就是num，如果打印的话，自然就是数组地址了。

如果问题未解决，请继续追问，如果问题解决了，请将问题分类改为“已解决”，谢谢