例：

package deep;

import java.util.Arrays;
import java.util.List;

public class Client {

    public static void main(String[] args) {
        Integer[] data = { 1, 2, 3, 4, 5 };
        List list = Arrays.asList(data);
        list.add(8);
    }

}

編譯沒有任何問題，但是一執行，卻出現瞭如下結果：
Exception in thread “main” java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at deep.Client.main(Client.java:11)

UnsupportedOperationException，不支援的操作？居然不支援List的add方法，這真是奇怪了！還是來追根尋源，看看asList方法的原始碼：

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

直接new了一個ArrayList物件返回，難道ArrayList不支援add方法？不可能呀！可能，問題就出在這個ArrayList類上，此ArrayList非java.util.ArrayList，而是Arrays工具類的一個內建類，如下所示：

 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是一個靜態私有內部類，除了Arrays能訪問外，其他類都不能訪問。仔細看這個類，它沒有提供add
方法，那肯定是父類AbstractList提供了，來看程式碼：

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

父類確實提供了，但沒有提供具體的實現（原始碼上是通過add方法呼叫add(int,E)方法來實現的，為了便於講解，此處縮減了程式碼），所以每個子類都需要自己覆寫add方法，而Arrays的內部類ArrayList沒有覆寫，因此add一個元素就會報錯了。
根據以上ArrayList的原始碼，對於我們經常使用的List.add和List.remove方法它都沒有實現，也就是說asList返回的是一個長度不可變的列表，陣列是多長，轉換成的列表也就是多長，不再保持列表動態變長的特性，換句話說此處的列表只是陣列的一個外殼！再看如下例子：

package deep;

import java.util.Arrays;
import java.util.List;

public class Client {

    public static void main(String[] args) {
        Integer[] data = { 1, 2, 3, 4, 5 };
        List list = Arrays.asList(data);
        list.set(2, 9);
        System.out.println(Arrays.toString(data));

    }

}

執行結果：
[1, 2, 9, 4, 5]

所以我們可以得出，asList返回的是陣列本質的集合，而陣列本身並沒有消失，對列表的任何操作最終都反映在陣列上。

我們最後再來看看asList的說明：
Open Declaration List java.util.Arrays.asList(Integer… a)

@SafeVarargs

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 Collection.toArray. The returned list is serializable and implements RandomAccess.

This method also provides a convenient way to create a fixed-size list initialized to contain several elements:

 List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

Parameters:
a the array by which the list will be backed
Returns:
a list view of the specified array