Arrays.asList的防坑指南

开发过程中，遇到数组转List集合后在进行相关操作的时候，很多同学一定会第一时间想到这个方法@SafeVarargs @SuppressWarnings("varargs") public static <T> List<T> asList(T... a) { return new ArrayList<>(a); }。但是这里面有三个雷区，大家一定要注意！

1.返回的并不是java.util下的ArrayList

这个方法返回的是Arrays内部自己继承AbstractList的一个内部类 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 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);
        }
    }

有没有发现什么重点？没错，就是他没有复写add/remove/clear这些方法。而调用这些方法会直接调用父类AbstractList中的add方法：

 public boolean add(E e) {
        add(size(), e);
        return true;
    }
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }

可以看到，这里直接会抛出一个UnsupportedOperationException的异常。是不是很惊喜。。这个一定要注意，如果要正常使用List的这些方法，需要再包一次，把他转换为util下的真正的ArrayList：

       String[] str = new String[]{"1","2"};
        List list = Arrays.asList(str);
        ArrayList arrayList = new ArrayList<>(list);

包装类型和基本类型的数组

在Arrays.asList中，该使用的是泛型，但是基础数据类型不是对象，不存在引用的概念，直接存在内存栈上面的，所以不能用泛型，这也是List<>不能放int等基础数据类型的原因。，一般可看做数组参数，但是如果传入的是int[] 的话，也就是一个基本类型的数组，编译器会把数组泛型化，认为只传了一个变量，这个变量的类型是int数组。这个就和我们预期有出入了：

int[] data = {1,2,3,4,5};

List list = Arrays.asList(data);

System.out.println("元素类型：" + list.get(0).getClass());

System.out.println("前后是否相等："+data.equals(list.get(0)));

 

可以看到，
输出的为元素类型:class [I
前后是否相等：true

所以，传入的数组一定要是包装类型，这样才能正确的转换为list：

Integer[] data = {1,2,3,4,5};

List list = Arrays.asList(data);

System.out.println("列表中的元素数量是：" + list.size());

输出结果：
列表中的元素数量是：5
说明编译器对Integer[] 处理不一样。Integer是可变长参数。传入过程中asList()方法实际是将Integer数组里的元素进行存储。

对数组的修改也会影响list

可以看Arrays的内部实现，他是把这个数组的引用直接给里面的成员：private final E[] a，所有的操作都是针对这个数组的操作，如果更改了原数组的元素，转换后的list的对应的下角标的元素也会改变：

       String[] str = new String[]{"1","2"};
        List list = Arrays.asList(str);
        str[0] = "unv";//那么list.get(0)也随着修改

总结

将数组转换为集合时，调用Arrays.asList这个方法后，我们尽量再包装一次new ArrayList<>(list)，将其转换为真正的java.util.ArrayList，这样会省去很多不必要的麻烦！