在Java中比如想把一个数组转成集合,通常习惯使用Arrays.asList,但是要小心,数组通过Arrays.asList转成集合后,是不能调用集合的add,remove方法的.不然会抛异常UnsupportedOperationException,

Demo

    Integer[] array = {1, 2};
    List<Object> list = Arrays.asList(array);
    list.remove(1);

控制台结果

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.remove(AbstractList.java:161)
    at com.study.webfluxstudy.ArrayListTest.main(ArrayListTest.java:19)

如果新人第一次碰到这个问题可能会感觉很奇怪,add,remove方法不应该是集合的标配吗,怎么会不支持呢?分析下底层源码就知道了

/**
     * Returns a fixed-size list backed by the specified array.
    */
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

Returns a fixed-size list backed by the specified array.很关键的一句话,asList返回的list是固定大小的,那也就是说生成后的集合就不能再添加删除了,也就是不能add,remove了.注释虽然是这么说,但是如果看方法体中的代码,return new ArrayList<>(a),是不是更奇怪了.ArrayList大家在项目中常用的集合类,add,remove没问题啊.是什么原因呢?
阅读源码其实就能发现此ArrayList不是彼ArrayList.
asList静态方法中的ArrayList是Lists中的一个私有静态类,而不是java.util.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);
        }
    }

    public static int hashCode(long a[]) {
        if (a == null)
            return 0;

        int result = 1;
        for (long element : a) {
            int elementHash = (int)(element ^ (element >>> 32));
            result = 31 * result + elementHash;
        }

        return result;
    }

通过上面的源码可以看到起没有提供add,remove方法的实现,那调用add,remove其实是调用父类的方法

AbstractList

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

    public E remove(int index) {
        throw new UnsupportedOperationException();
    }

所以也就能解释为什么Demo演示代码调用add方法,在控制台会抛出UnsupportedOperationException异常了

如果让Arrays.asList()返回的集合支持add,remove方法

如果想实现这个目的需要借助java.util.ArrayList帮忙

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

调整后的Demo

    Integer[] array = {1, 2};
    // 通过Arrays转换成的List,保留了原本的类型
    List<Integer> list = Arrays.asList(array);
    System.out.println(list);
    ArrayList<Integer> objects = new ArrayList<Integer>(list);
    objects.add(3);
    System.out.println(objects);

控制台输出

[1, 2]
[1, 2, 3]