面试：Arrays.asList 获得的 List 使用时需要注意什么？

Arrays.asList的源码：

public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);  // Arrays的内部ArrayList类实现，java.util.Arrays.ArrayList,而不是java.util.ArrayList
}

这个内部类如下：

/**
 * @description 内部实现
 * 初始化一个定长的数组集合对象；
 * 不支持基础类型转换的
 */
private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        
        // 定义为final级别，也就是不能对该对象重新初始化
        private final E[] a;
        
        // 构造函数
        ArrayList(E[] array) {
            // 检查指定的对象引用是否为空。这个方法主要用于在方法和构造函数中进行参数验证
            a = Objects.requireNonNull(array);
        }
        
        /**
         * 返回数据的大小
         */
        @Override
        public int size() {
            return a.length;
        }
        
        /**
         * 返回a数组的浅拷贝对象
         */
        @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;
        }

        /**
         * 获取a数组指定位置的数据
         */
        @Override
        public E get(int index) {
            return a[index];
        }

        /**
         * 重新设置a数组指定位置的数据，并返回对应的旧值
         */
        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }
        
        /**
         * 判断对象是否存在，如果入参为null,那就找出第一个null值的记录返回下角标数字；
         * 如果入参不为空，就equals方法，找到第一个对应的记录，返回下角标数字；
         * 如果没有查找到数据，默认返回-1
         */
        @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;
        }
        
        
        /**
         * 默认调用indexOf方法查找数据是否存在
         */
        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        /**
         * 在列表中的元素上创建一个后期绑定和快速失败的Spliterator
         */
        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }
        
        /**
         * 默认实现java8流式遍历
         */
        @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 对象，无法进行add、remove、addAll,因为该父类未实现该方法，默认抛出 UnsupportedOperationException 异常对象。

需要进行一些操作时，请使用ArrayList包装一下，如：

new java.util.ArrayList<String>(Arrays.asList("张三","李四"));