Arrays.asList() 的了解

为什么Arrays.asList() 返回的list是 immutable的？

原因是：返回的list本质上是Arrays类的一个内部类，这个类没有change structure的方法（add remove等方法全都改写成直接抛出unsupported operation异常），所以他是immutable的。

 

源代码分析：

将一个数组转化为一个List对象，一般会想到Arrays.asList()方法，这个方法会返回一个ArrayList类型的对象。但是用这个对象对列表进行添加删除更新操作，就会报UnsupportedOperationException异常。

    

[java]  view plain copy

 

1. public static <T> List<T> asList(T... a) {  
2.     return new ArrayList<T>(a);  
3.     }  

    这个ArrayList类并非java.util.ArrayList类，而是Arrays类的静态内部类！

 

 

[java]  view plain copy

 

1. public class Arrays {  
2.     .......  
3.   
4.     private static class ArrayList<E> extends AbstractList<E>  
5.         implements RandomAccess, java.io.Serializable  
6.         {  
7.         private static final long serialVersionUID = -2764017481108945198L;  
8.         private final E[] a;  
9.   
10.         ArrayList(E[] array) {  
11.             if (array==null)  
12.             throw new NullPointerException();  
13.             a = array;  
14.         }  
15.           
16.         ......  
17.     }  
18. }  

    再看这个静态内部类，存储数组元素的a变量是final类型的，由此判断，这个静态内部类是不能做任何内部元素的添加删除操作的！就跟String类一样，String对象存储字符数组的变量也是有final修饰符的。因为一旦增加数组元素，这个数组容量已经定好的容器就无法装载增加的元素了。

 

    内部类里面并没有add,remove方法，这个类继承的AbstractList类里面有这些方法。

 

[java]  view plain copy

 

1. public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {  
2.     ........  
3.   
4.     public void add(int index, E element) {  
5.     throw new UnsupportedOperationException();  
6.     }  
7.   
8.     public E remove(int index) {  
9.     throw new UnsupportedOperationException();  
10.     }  
11. }  

    可以看出来，AbstractList这个抽象类所定义的add和remove方法，仅仅是抛出了一个异常！为什么不是定义成一个抽象方法呢？然后让实现类去实现。
    所以，如果是想将一个数组转化成一个列表并做增加删除操作的话，建议代码如下：

 

 

[java]  view plain copy

 

1. List<WaiterLevel> levelList = new ArrayList<WaiterLevel>(Arrays.asList("a", "b", "c"));  

 

 

下面是概述：

http://xixinfei.iteye.com/blog/1260852

将数组转成List问题，通常我们习惯这样写成：List<String> list = Arrays.asList("1","2");

于是我们这样就得到了一个list,但是这个List的实现类是java.util.Arrays.ArrayList这个类(而不是java.util.ArrayList)。

剖析JDK源代码可以发现,java.util.Arrays.ArrayList(就是转换出来list)它是继承了java.util.AbstractList这个类。

再来看看java.util.AbstractList类是啥样子的？可以发现

public E set(int index, E element)

public E set(int index, E element)

public E remove(int index)

public void add(int index, E element)  | public boolean add(E e)调用add(int index, E element)

以上方法的实现全部是抛出UnsupportedOperationException异常。

因此有Arrays.asList转换出来的List他其实是一个AbstractList,他可以像List一样访问，但是不可其做任何修改操作。

这也说明了，为什么Arrays.asList出来的List，对其做add、remove操作为抛出UnsupportedOperationException异常，从JDK代码角度上，原因在此。

换句话说，其实java.util.Arrays.ArrayList其实只是对数组做了一个装饰，可以看到里面的实现，E get(int index)、E set(int index, E element)等方法都是对数组的操作，他的目的只是提供了可以像访问List那样来访问数组而已。本质上其实还是一个数组。

 

 

 

//   自己做个简单的例子

 

public class Te {
      public static void main(String[] args){
       String[] in={"4","2","4","5","7"};
       
       List isn=Arrays.asList(in);

//       修改操作
       isn.set(1, "9");
       for(int i=0;i<isn.size();i++){
        System.out.println(isn.get(i));
       }
      }
}

====================

JDK 1.4对java.util.Arrays.asList的定义，函数参数是Object[]。所以，在1.4中asList()并不支持基本类型的数组作参数。

 JDK 1.5中，java.util.Arrays.asList的定义，函数参数是Varargs, 采用了泛型实现。同时由于autoboxing的支持，使得可以支持对象数组以及基本类型数组。

 不过在使用时，当传入基本数据类型的数组时，会出现小问题，会把传入的数组整个当作返回的List中的第一个元素，例如：

view source print ?

1	public static void main(String[] args){

2	int[] a1 = new int[]{1,2,3};

3	String[] a2 = new String[]{"a","b","c"};

4

5	System.out.println(Arrays.asList(a1));

6	System.out.println(Arrays.asList(a2));

7

}

　　

打印结果如下：

view source print ?

1	[[I@dc8569]

2

[a, b, c]

　　

下面说说Arrays.asList()的返回值：

JDK文档是这么说的：

public static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。此方法还提供了一个创建固定长度的列表的便捷方法，该列

view source print ?

01

/**

02	* @serial include

03

*/

04	private static class ArrayList<E> extends AbstractList<E> implementsRandomAccess, java.io.Serializable {

05	private static final long serialVersionUID = -2764017481108945198L;

06	private final E[] a;

07

08	ArrayList(E[] array) {

09	if (array == null)

10	throw new NullPointerException();

11	a = array;

12

}

13

14	public int size() {

15	return a.length;

16

}

17

18	public Object[] toArray() {

19	return a.clone();

20

}

21

22	public <T> T[] toArray(T[] a) {

23	int size = size();

24	if (a.length < size)

25	return Arrays.copyOf(this.a, size, (Class<? extendsT[]>) a.getClass());

26	System.arraycopy(this.a, 0, a, 0, size);

27	if (a.length > size)

28	a[size] = null;

29

return a;

30

}

31

32	public E get(int index) {

33	return a[index];

34

}

35

36	public E set(int index, E element) {

37	E oldValue = a[index];

38	a[index] = element;

39	return oldValue;

40

}

41

42	public int indexOf(Object o) {

43	if (o == null) {

44	for (int i = 0; i < a.length; i++)

45	if (a[i] == null)

46

return i;

47

} else {

48	for (int i = 0; i < a.length; i++)

49	if (o.equals(a[i]))

50

return i;

51

}

52	return -1;

53

}

54

55	public boolean contains(Object o) {

56	return indexOf(o) != -1;

57

}

58

}

　　

表被初始化为包含多个元素： List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

我们都知道，List的一个典型的特性就是其长度是可变的，我们可以很方便地对它进行插入和删除元素的操作，这是它与数组所存在的一个很大的区别，后者的长度是固定的，而且我们不能从数组中删除元素，只能修改元素的值。利用Arrays.asList(array)将返回一个List，然而这个返回的List并不支持add和remove的操作。

这是什么原因呢？

Arrays.asList源码：

view source print ?

1	public static <T> List<T> asList(T... a) {

2	return new ArrayList<T>(a);

3

}

　　

这里的ArrayList并不是java.util.ArrayList，而是Arrays的内部类：

 

我们可以看到该内部类继承的是AbstractList，下面是AbstractList的add和remove方法源码：

 

view source print ?

01	public boolean add(E e) {

02	add(size(), e);

03	return true;

04

}

05

06	public void add(int index, E element) {

07	throw new UnsupportedOperationException();

08

}

09

10	public E remove(int index) {

11	throw new UnsupportedOperationException();

12

}

 

　　

 

所以，当我们对Arrays.asList返回的List进行添加或删除时将会报 java.lang.UnsupportedOperationException 异常。