将数组转换成集合Arrays.asList,不可进行add和remove操作的原因

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_34115899/article/details/80513271

直接上代码:

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

public class Test {
    public static void main(String[] args) {  
        Integer a[] = {1,2,5,6,9};
        List<Integer> list = Arrays.asList(a);
        System.out.println(list.size());
        list.add(3);
        System.out.println(list.size());
    }
}

运行结果:

原因看源码:

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

new了一个ArrayList集合,注意了,这个可不是ArrayList类,而是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);
        }
    }

内部类没有add和remove当然不能进行这些操作了,但是修改set还是可以的。

 

官方文档解释:

asList
public static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。(对返回列表的更改会“直接写”到数组。)此方法同 Collection.toArray() 一起,充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的,并且实现了 RandomAccess。
此方法还提供了一个创建固定长度的列表的便捷方法,该列表被初始化为包含多个元素:
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
参数:
a - 支持列表的数组。
返回:
指定数组的列表视图。

 

用asList转换的代码是返回List的实现类ArrayList集合对象

但是集合大小固定,无法添加和删除

如果想要将数组转换成一个可以具有正常添加和删除操作的List话,

一种情况就是遍历数组,一个个添加到list中

或者用Collections.addAll(list, a);

又或者直接new ArrayList<...>(Arrays.asList(a))放入另一个ArrayList

 

关于Collections.addAll文档显示:

addAll
public static <T> boolean addAll(Collection<? super T> c,
                                 T... elements)
将所有指定元素添加到指定 collection 中。可以分别指定要添加的元素,或者将它们指定为一个数组。此便捷方法的行为与 c.addAll(Arrays.asList(elements)) 的行为是相同的,但在大多数实现下,此方法运行起来可能要快得多。
在分别指定元素时,此方法提供了将少数元素添加到现有 collection 中的一个便捷方式:

     Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");
 
参数:
c - 要插入 elements 的 collection
elements - 插入 c 的元素
返回:
如果 collection 由于调用而发生更改,则返回 true
抛出:
UnsupportedOperationException - 如果 c 不支持 add 操作
NullPointerException - 如果 elements 包含一个或多个 null 值并且 c 不允许使用 null 元素,或者 c 或 elements 为 null
IllegalArgumentException - 如果 elements 中值的某个属性不允许将它添加到 c 中
从以下版本开始:
1.5
另请参见:

Collection.addAll(Collection)

 

文档写出如果第一个参数集合c如果不支持add操作仍然抛出UnsupportedOperationException,就比如刚刚用一个数组List<Integer> list = Arrays.asList(a);此时的list不允许add操作,会抛出UnsupportedOperationException,同样的,此时再进行Collections.addAll(list, a);也是会抛出UnsupportedOperationException。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {  
        Integer a[] = {1,2,5,6,9};
        List<Integer> list = new ArrayList<>();
        System.out.println(list.size());
        Collections.addAll(list, a);
        list.add(3); // 此时的添加是可以成功的
        System.out.println(list.size());
    }
}

运行结果:

 

附赠一个踩坑题:

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

public class Test {
    public static void main(String[] args) {
        int[] a = new int[] { 1, 2, 3, 4 };
        List list = Arrays.asList(a);
        System.out.println(list.size());
    }
}

这个程序输出是什么???

是4吗???

 

运行结果是1 

看一下源码:

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

因为基本类型是不能做泛型参数的,这里的a接收引用类型,即List<int[]> list = Arrays.asList(a);

就是1个int[]数组。要想解决这个问题,将int[]改为Integer[]即可,那么答案就是4了。

 

 

==========================Talk is cheap, show me the code==========================

展开阅读全文

没有更多推荐了,返回首页