關於ArraysList.AsList()返回對象不能使用add()增加元素的探討。

JAVA編程思想的第十一章持有對象中有這樣一個問題。

其代碼如下（在尋找錯誤原因的時候，我對代碼已進行了少量修改）：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class AddGroups {
	public static void main(String[] aaa) {
		Collection<Integer> collection = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5));
		
		Integer[] moreInt = {6,7,8,9,10};
		
		Collections.addAll(collection, moreInt);
		Collections.addAll(collection, 11,12,13,14,15);
		
		List<Integer> list = Arrays.asList(16,17,18,19,20);
		list.set(1, 99);
//		((ArrayList<Integer>)list).add(3);
		list.add(3);
		List<Integer> list2 = new ArrayList<Integer>();
		list2.add(30);
		
		System.out.println("list究竟是什麼？");
		System.out.println(list);
		System.out.println(list.getClass());
		
		for(Integer i:list2){
			System.out.print(i+" ");
		}
		System.out.println("abc");
		for(Integer i:collection) {
			System.out.print(i+" ");
		}
	}
}

這段代碼在Eclipse上運行的時候會提示如下錯誤：

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.base/java.util.AbstractList.add(AbstractList.java:153)
    at java.base/java.util.AbstractList.add(AbstractList.java:111)
    at cn.dzr.AddGroups.main(AddGroups.java:21)

其原因就在於list無法使用add()方法。

 

關於這個錯誤，書上有進行解釋：
       你也可以直接使用Arrays.AsList()的輸出，將其當作List，但是在這種情況下，其底層表示是數組，因而不能調整尺寸。如果你試圖用add或者delete操作，就有可能引發改變數組尺寸的嘗試，因此，你在運行時將會獲得UnsupportedOperation（不支持的操作）錯誤。
 
 當這個解釋讓我感到有些疑惑：
  因爲在我印象中，所有集合的底層都是數組。只是在容器中，有一系列的方法和參數來那些對數組進行操作，使得其具有add，remove等功能。
  
  隨後，我在代碼中添加了這三行，

  System.out.println("list究竟是什麼？");
		System.out.println(list);
		System.out.println(list.getClass());

其輸出如下：

 [16, 99, 18, 19, 20]
   class java.util.Arrays$ArrayList

這個list就是一個ArrayList，隨後，我打開ArrayList的add代碼，其具體如下：

 public void add(int index, E element) {
        rangeCheckForAdd(index);
        modCount++;
        final int s;
        Object[] elementData;
        if ((s = size) == (elementData = this.elementData).length)
            elementData = grow();
        System.arraycopy(elementData, index,
                         elementData, index + 1,
                         s - index);
        elementData[index] = element;
        size = s + 1;
    }

這裏看起來根本就沒有拋出異常。
  
  隨後，我又簡單的翻看了下ArrayList的代碼，觀察其構造函數，但也沒有找到半點與“底層是數組，所以無法調整長度”相關的原因。
  
  與此同時，我又通過在Eclipse裏點擊
  at java.base/java.util.AbstractList.add(AbstractList.java:111)
  隨後代碼跳到了AbstractList裏，

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

這裏倒是剛好有我們的那個錯誤。但是我們使用ArrayList進行操作，爲什麼會調用其父類的一個對象。
    ArrayList裏的add函數，我早就已經調查清楚。
    
    到了這裏，我頭腦一直都是混亂，理不清頭緒。
    隨後，我突然發現了一個問題。
    
    list的類型，其實並不是ArrayList，它是class java.util.Arrays$ArrayList。
    他並不是我們常用的一個容器類，而只是Arrays類中的一個內部類。
    
    隨後，問題就迎刃而解了。我們觀看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) {
            a = Objects.requireNonNull(array);
        }

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

        @Override
        public Object[] toArray() {
            return Arrays.copyOf(a, a.length, Object[].class);
        }

        @Override
        @SuppressWarnings("unchecked")
        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;
        }

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

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            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;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) >= 0;
        }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }

        @Override
        public Iterator<E> iterator() {
            return new ArrayItr<>(a);
        }
	}

我們可以看到，其裏面根本就沒有add()方法，但是有一個set方法。所以，我們在用list.add()操作時，程序會自動調用其基類的add()方法，也就是

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

這樣，自然就拋出了異常。
    
    所以，編程思想這本書關於這個問題的解釋實在是有些牛頭不對馬嘴，在這裏報錯的原因，只是因爲list實際指向的對象的類型（Arrays裏面的ArrayList類型)根本就沒有實現這個add()方法，跟其底層是數組沒有任何的關係。