Arrays.asList说明

在java.util包中提供了一个特别实用的数组相关的工具类Arrays,可以对数组进行二分查找、复制新数组、深度比较、填充数组和排序等操作。并且，Arrays还提供了一个方法
public static <T> List<T> asList(T... a)来让普通数组或者元素填充转化为List。

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

public class Test {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("1","2","3");
        System.out.println(list);//[1, 2, 3]

        List<Integer> list2 = Arrays.asList(1,2,3,4,5);
        System.out.println(list2);//[1, 2, 3, 4, 5]
        
        Object[] obj = {"1", 1, new HashMap(), false};
        List<Object> list3 = Arrays.asList(obj);
        System.out.println(list3);//[1, 1, {}, false]
    }
}

我们可以非常方便地对这个返回地list进行单列集合地相关操作，例如:get、set、indexOf等。

但是，我们不能对其进行add、remove等操作，否则会抛出异常！

list3.add("list");
list.remove(1);

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(AbstractList.java:148)
    at java.util.AbstractList.add(AbstractList.java:108)
    at com.atguigu.spring.helloworld.Test.main(Test.java:20)

为什么会这样呢？查看asList方法的源码会发现：

    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

返回地ArrayList不是java.util.ArrayList而是java.util.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) {
            a = Objects.requireNonNull(array);
        }

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

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

        @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) != -1;
        }

        @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);
        }
    }

这个类继承自AbstractList，并实现了随机访问和序列化接口，但是，它没有完整的实现List接口中的全部方法，包括add、remove，所以在使用未覆写的方法时就会抛出java.lang.UnsupportedOperationException！！

    //java.util.AbstractList源码
    ...
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }
    public E remove(int index) {
        throw new UnsupportedOperationException();
    }
    ...

那么如果，相对转化的list进行完整的List接口中所有方法的操作呢？

1. 迭代 Arrays.asList返回的list，并将其放入一个新的ArrayList中，然后操作这个ArrayList
   当然这种方法很低效，而且，为什么一开始就将数组迭代放入ArrayList呢？

2.new 一个新的ArrayList，将Arrays.asList返回的list,直接作为入参传入ArrayList构造器，然后操作这个新的ArrayList。

//单列集合都可以接受单列集合作为参数传入构造器
//并且这个过程，就是copy底层维护的Object数组
public ArrayList(Collection<? extends E> c)