关于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()方法，跟其底层是数组没有任何的关系。