Arrays.asList() 得到 集合 执行 add() 和 remove() 抛 UnsupportedOperationException 异常

通过 Arrays.asList() 得到集合
对这个集合进行 add() 和 remove() 操作
抛出java.lang.UnsupportedOperationException异常


直接根据 甲骨文官方的api 解释 入手
static <T> List<T> asList(T... a)
Returns a fixed-size list backed by the specified array.


很清晰 
该方法 返回由指定数组支持的固定大小的列表


再从源码入手


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


可以发现 该方法最终返回一个 ArrayList （注意，问题就是在这个地方引起的）


这个 ArrayList 不是我们 常用的那个 java.util.ArrayList


在源码中发现


在 Arrays 中 内部维护了一个内部类 ArrayList 


private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;


ArrayList(E[] array) {
            if (array==null)
                throw new NullPointerException();
   a = array;
}


public int size() {
   return a.length;
}


public Object[] toArray() {
   return a.clone();
}


public <T> T[] toArray(T[] a) {
   int size = size();
   if (a.length < size)
return Arrays.copyOf(this.a, size,
    (Class<? extends T[]>) a.getClass());
   System.arraycopy(this.a, 0, a, 0, size);
   if (a.length > size)
a[size] = null;
   return a;
}


public E get(int index) {
   return a[index];
}


public E set(int index, E element) {
   E oldValue = a[index];
   a[index] = element;
   return 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 在该 ArrayList 内部没有重写 add() 和 remove() 方法
所以在执行这俩个方法的时候 他是直接调用父类的


public boolean add(E e) {
add(size(), e);
return true;
}


public void add(int index, E element) {
throw new UnsupportedOperationException();
}


public E remove(int index) {
throw new UnsupportedOperationException();
}


到此为止 所以的谜团都已经解开了。