Arrays.asList()使用注意点

　　今天看代码时, 发现书上使用了Arrays.asList()方法, 将一个数组转成了List, 然后说到得到的List不能调用add(), remove()方法添加元素或者删除,带着疑问看了下内部实现原理, 看了别人博客明白了, 为啥不能调用add(), remove()方法了.下面是转载的一篇文章.

转载:http://www.lai18.com/content/10306565.html

Arrays工具类提供了一些比较实用的方法，比如sort, binarySearch, fill等。其中还有一个asList方法，此方法能够将一个变长参数或者数组转换成List。

但是，这个生成的List，它是固定长度的，如果对其进行add或者remove的操作，会抛出UnsupportedOperationException，为什么会这样呢？

带着疑问，查看一下Arrays的源码，可以得到问题的结果。

/**
     * Returns a fixed-size list backed by the specified array.  (Changes to
     * the returned list "write through" to the array.)  This method acts
     * as bridge between array-based and collection-based APIs, in
     * combination with <tt>Collection.toArray</tt>.  The returned list is
     * serializable and implements {@link RandomAccess}.
     *
     * <p>This method also provides a convenient way to create a fixed-size
     * list initialized to contain several elements:
     * <pre>
     *     List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
     * </pre>
     *
     * @param a the array by which the list will be backed.
     * @return a list view of the specified array.
     * @see Collection#toArray()
     */
    public static <T> List<T> asList(T... a) {
	return new ArrayList<T>(a);
}

方法asList返回的是new ArrayList<T>(a)。但是，这个ArrayList并不是java.util.ArrayList，它是一个Arrays类中的重新定义的内部类。

具体的实现如下：

/**
     * @serial include
     */
    private static class ArrayList<E> extends AbstractList<E>
	implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
	private Object[] a;
	ArrayList(E[] array) {
            if (array==null)
                throw new NullPointerException();
	    a = array;
	}
	public int size() {
	    return a.length;
	}
	public Object[] toArray() {
	    return (Object[])a.clone();
	}
	public E get(int index) {
	    return (E)a[index];
	}
	public E set(int index, E element) {
	    Object oldValue = a[index];
	    a[index] = element;
	    return (E)oldValue;
	}
        public int indexOf(Object o) {
            if (o==null) {
                for (int i=0; i<a.length; i++)
                    if (a[i]==null)
                        return i;
            } else {
                for (int i=0; i<a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }
    }

从这个内部类ArrayList的实现可以看出，它继承了类AbstractList<E>,但是没有重写add和remove方法，没有给出具体的实现。查看一下AbstractList类中对add和remove方法的定义，如果一个list不支持add和remove就会抛出UnsupportedOperationException。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    /**
     * Sole constructor.  (For invocation by subclass constructors, typically
     * implicit.)
     */
    protected AbstractList() {
}
/**
     * Appends the specified element to the end of this List (optional
     * operation). <p>
     *
     * This implementation calls <tt>add(size(), o)</tt>.<p>
     *
     * Note that this implementation throws an
     * <tt>UnsupportedOperationException</tt> unless <tt>add(int, Object)</tt>
     * is overridden.
     *
     * @param o element to be appended to this list.
     *
     * @return <tt>true</tt> (as per the general contract of
     * <tt>Collection.add</tt>).
     *
     * @throws UnsupportedOperationException if the <tt>add</tt> method is not
     * 		  supported by this Set.
     *
     * @throws ClassCastException if the class of the specified element
     * 		  prevents it from being added to this set.
     *
     * @throws IllegalArgumentException some aspect of this element prevents
     *            it from being added to this collection.
     */
    public boolean add(E o) {
	add(size(), o);
	return true;
    }
    /**
     * Inserts the specified element at the specified position in this list
     * (optional operation).  Shifts the element currently at that position
     * (if any) and any subsequent elements to the right (adds one to their
     * indices).<p>
     *
     * This implementation always throws an UnsupportedOperationException.
     *
     * @param index index at which the specified element is to be inserted.
     * @param element element to be inserted.
     *
     * @throws UnsupportedOperationException if the <tt>add</tt> method is not
     *		  supported by this list.
     * @throws ClassCastException if the class of the specified element
     * 		  prevents it from being added to this list.
     * @throws IllegalArgumentException if some aspect of the specified
     *		  element prevents it from being added to this list.
     * @throws IndexOutOfBoundsException index is out of range (<tt>index <
     *		  0 || index > size()</tt>).
     */
    public void add(int index, E element) {
	throw new UnsupportedOperationException();
    }
    /**
     * Removes the element at the specified position in this list (optional
     * operation).  Shifts any subsequent elements to the left (subtracts one
     * from their indices).  Returns the element that was removed from the
     * list.<p>
     *
     * This implementation always throws an
     * <tt>UnsupportedOperationException</tt>.
     *
     * @param index the index of the element to remove.
     * @return the element previously at the specified position.
     *
     * @throws UnsupportedOperationException if the <tt>remove</tt> method is
     *		  not supported by this list.
     * @throws IndexOutOfBoundsException if the specified index is out of
     * 		  range (<tt>index < 0 || index >= size()</tt>).
     */
    public E remove(int index) {
	throw new UnsupportedOperationException();
    }
}

至此，为什么Arrays.asList产生的List是不可添加或者删除，否则会产生UnsupportedOperationException，就可以得到解释了。

同时我们可以用List来接受Arrays.asList(array)返回的参数、原因是Arrays.asList(array)返回的虽然不是java.util.ArrayList但是返回的ArrayList同理也继承自AbstractList

我们的AbstractList实现自List接口、所以可以用list接口来引用Arrays.asList(array)；

如果我们想把一个变长或者数据转变成List， 而且期望这个List能够进行add或者remove操作，那该怎么做呢？ 

我们可以写一个类似的方法，里面直接采用java.util.ArrayList即可。 

比如：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MyArrays {
	public static <T> List<T> asList(T... a) {
		List<T> list = new ArrayList<T>();
		Collections.addAll(list, a);
		return list;
	}
}

测试代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Test {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
		print(stooges);
		List<List<String>> seasonsList = Arrays.asList(retrieveSeasonsList());
		print(seasonsList);
		/*
		 * 自己实现一个asList方法，能够添加和删除。
		 */
		List<String> list = MyArrays.asList("Larry", "Moe", "Curly");
		list.add("Hello");
		print(list);
	}
	private static <T> void print(List<T> list) {
		System.out.println(list);
	}
	private static List<String> retrieveSeasonsList() {
		List<String> seasonsList = new ArrayList<String>();
		seasonsList.add("Spring");
		seasonsList.add("Summer");
		seasonsList.add("Autumn");
		seasonsList.add("Winter");
		return seasonsList;
	}
}

输出结果： 

[Larry, Moe, Curly] 

[[Spring, Summer, Autumn, Winter]] 

[Larry, Moe, Curly, Hello]