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

以上是API 1.6的说明，这个方法是Collection和数组之间的桥梁。下面我们看看asList的源码：

1. <font face="Arial">    @SafeVarargs
   
2.     @SuppressWarnings("varargs")
   
3.     public static <T> List<T> asList(T... a) {
   
4.         return new ArrayList<>(a);
   
5.     }</font>

复制代码

参数是可变参数，可变参数按照数组来处理，注意这条语句：

1. <font face="Arial">return new ArrayList<>(a);</font>

复制代码

这里的ArrayList并不是API中的ArrayList，而是Arrays类的一个私有的静态内部类（设计师就不能换个名字嘛- -！简直迷惑众人），我们看看他的实现：

1. private static class ArrayList<E> extends AbstractList<E>
   
2.         implements RandomAccess, java.io.Serializable
   
3.     {
   
4.         private static final long serialVersionUID = -2764017481108945198L;
   
5.         private final E[] a;
   
6. 
   
7.         ArrayList(E[] array) {//可变参数可以匹配到这个构造器  
   
8.             a = Objects.requireNonNull(array);
   
9.         }
   
10. 
    
11.         @Override
    
12.         public int size() {
    
13.             return a.length;
    
14.         }
    
15. 
    
16.         @Override
    
17.         public Object[] toArray() {
    
18.             return a.clone();
    
19.         }
    
20. 
    
21.         @Override
    
22.         @SuppressWarnings("unchecked")
    
23.         public <T> T[] toArray(T[] a) {
    
24.             int size = size();
    
25.             if (a.length < size)
    
26.                 return Arrays.copyOf(this.a, size,
    
27.                                      (Class<? extends T[]>) a.getClass());
    
28.             System.arraycopy(this.a, 0, a, 0, size);
    
29.             if (a.length > size)
    
30.                 a[size] = null;
    
31.             return a;
    
32.         }
    
33. 
    
34.         @Override
    
35.         public E get(int index) {
    
36.             return a[index];
    
37.         }
    
38. 
    
39.         @Override
    
40.         public E set(int index, E element) {
    
41.             E oldValue = a[index];
    
42.             a[index] = element;
    
43.             return oldValue;
    
44.         }
    
45. 
    
46.         @Override
    
47.         public int indexOf(Object o) {
    
48.             E[] a = this.a;
    
49.             if (o == null) {
    
50.                 for (int i = 0; i < a.length; i++)
    
51.                     if (a[i] == null)
    
52.                         return i;
    
53.             } else {
    
54.                 for (int i = 0; i < a.length; i++)
    
55.                     if (o.equals(a[i]))
    
56.                         return i;
    
57.             }
    
58.             return -1;
    
59.         }
    
60. 
    
61.         @Override
    
62.         public boolean contains(Object o) {
    
63.             return indexOf(o) != -1;
    
64.         }
    
65. 
    
66.         @Override
    
67.         public Spliterator<E> spliterator() {
    
68.             return Spliterators.spliterator(a, Spliterator.ORDERED);
    
69.         }
    
70. 
    
71.         @Override
    
72.         public void forEach(Consumer<? super E> action) {
    
73.             Objects.requireNonNull(action);
    
74.             for (E e : a) {
    
75.                 action.accept(e);
    
76.             }
    
77.         }
    
78. 
    
79.         @Override
    
80.         public void replaceAll(UnaryOperator<E> operator) {
    
81.             Objects.requireNonNull(operator);
    
82.             E[] a = this.a;
    
83.             for (int i = 0; i < a.length; i++) {
    
84.                 a[i] = operator.apply(a[i]);
    
85.             }
    
86.         }
    
87. 
    
88.         @Override
    
89.         public void sort(Comparator<? super E> c) {
    
90.             Arrays.sort(a, c);
    
91.         }
    
92.     }

复制代码

这个私有静态内部类继承自AbstractList抽象类，然而却并没有覆写AbstractList的add和remove方法，我们再看看AbstractList的add和remove方法：

1.     public E set(int index, E element) {
   
2.         throw new UnsupportedOperationException();
   
3.     }
   
4. 
   
5.     public void add(int index, E element) {
   
6.         throw new UnsupportedOperationException();

复制代码

这两个方法直接抛出了UnsupportedOperationException异常，这也就是通过asList方法得到的List集合长度固定，不支持增删操作的根本原因。

如果想做增删操作可以这样处理：List list=new ArrayList(Arrays.asList(1,2,3,4,5));

赞，就是目前水平难得看懂

:time::(Objects.requireNonNull(array);