java中的Arrays.asList()浅析

亦凉 2022-05-23 11:57 228阅读 0赞

1.Arrays.asList(T..)使用的是静态内部类:ArrayList, (没有定义add和remove等一些方法),而不是java.util.ArrayList

/** * 1.测试Arrays.asList()方法 * @author zhangdi * @description * 使用的是静态内部类:ArrayList, (没有定义add和remove等一些方法),而不是java.util.ArrayList * 接受的参数被一个final修饰的成员变量 private final E[] a接受 * 调用Arrays.asList()的add和remove方法 会抛异常:java.lang.UnsupportedOperationException */
        @Test
        public void testAsListOfArray() {
            List<String> list = Arrays.asList("1", "2", "3");
            list.add("4");
            for (String string : list) {
                System.out.println("string:" + string);
            }
        }
    
        @Test
        public void testAsListOfArray2() {
            List<String> list = new ArrayList<>();
            list.add("5");
            list.add("6");
            list.add("7");
            list.add("8");
            for (String string : list) {
                System.out.println("string:" + string);
            }
        }

2.为什么`List<int[]> asList2 = Arrays.asList(d);`返回的是`List<int[]>`而不是`List<int>`呢?为什么`testAsListOfArray3`中的`list.size():`输出1而不是4呢?

/** * 2.Array.asList()接收基本类型与单个元素 * @author zhangdi * @see https://stackoverflow.com/questions/1467913/arrays-aslist-not-working-as-it-should */
        @Test
        public void testAsListOfArray3(){
            //1
            int[] f = {
       1,2,3,4};
            List list = Arrays.asList(f);
            System.out.println("list.size():"+list.size());  //output: list.size():1
    
            //2
            int[] a = {
       1,2,3,4,8,10,22,12,214,23};  
            String[] b = {
       "a","b","c"};  
            Integer[] c = {
       1,2,3,4,8,10,22,12,214,23};
            System.out.println(Arrays.asList(a));  
            System.out.println(Arrays.asList(b));  
            System.out.println(Arrays.asList(c)); 
    
            //3
            //There's no such thing as a List<int> in Java - generics don't support primitives.
            //Autoboxing only happens for a single element, not for arrays of primitives.
            //java arrays are objects and Arrays.asList() treats your int array as a single argument in the varargs list.
            int[] d = new int[]{
       1,2,3,4,8,10,22,12,214,23};  
            Integer[] e = new Integer[]{
       1,2,3,4,8,10,22,12,214,23}; //避免使用原始类型数组作为asList的输入参数
            List<int[]> asList2 = Arrays.asList(d);
            List<Integer> asList3 = Arrays.asList(e);
            System.out.println(asList2);  
            System.out.println(asList3);  
           // output:
            /* 1 [[I@232d49d1] //会被当做一个参数接收 [a, b, c] [1, 2, 3, 4, 8, 10, 22, 12, 214, 23] [[I@ef05133d] [1, 2, 3, 4, 8, 10, 22, 12, 214, 23] */
        }

因为:Arrays.asList()方法接受一个可变参数T，一般可看做数组参数，但是因为int\[\] 本身就是一个类型，所以a变量作为参数传递时，编译器认为只传了一个变量，这个变量的类型是int数组，所以size为1，相当于是List中数组的个数。**基本类型是不能作为泛型的参数**，要想作为泛型化参数就必须使用其对应的包装类型。 按道理此处应该使用包装类型，但这里却没有报错，因为数组是可以泛型化的，所以转换后在list中就有一个类型为int的数组; 所以 ,以后要**避免使用原始类型数组作为asList的输入参数**.

另外,java8的一些写法:学习一下

//1
    Integer[] boxedInts = IntStream.of(ints).boxed().toArray(Integer[]::new);
    List<Integer> boxedInts = IntStream.of(ints).boxed().collect(Collectors.toList());
    //2
    Integer[] boxedIntArray = Arrays.stream(ints).boxed().toArray(Integer[]::new);
    List<Integer> boxedIntList = Arrays.stream(ints).boxed().collect(Collectors.toList());

1.  自己实现一个asList方法，能够add和remove; (比较一下自己和源码的写法)

/** * @author zhangdi * @param strings * @return 目的也是为了让返回的list是一个可操作的list * @description jdk 中Arrays.asList()是一个静态方法: */
        @SafeVarargs
        private static <T> List<T> asList(T... args) {
            List<T> list = new ArrayList<>();
            for (T a : args) {
                list.add(a);
            }
            return list;
        }

Arrays.asList()的手写第二个版本(目的也是为了让返回的list是一个可操作的list):

/** * @author zhangdi * @param a * @return * @description asList_v2 比用for更为简洁 */
        @SafeVarargs
        public static <T> List<T> asList_v2(T... a) {  
            List<T> list = new ArrayList<T>();  
            Collections.addAll(list, a);  
            return list;  
        }

实际上,addAll底层用的也是for循环,还有一个 **result |= c.add(element);**操作,可以学习一下

/** * jdk_source: * 把所有指定元素添加到集合c中， 有一个元素添加成功就返回true */  
        public static <T> boolean addAll(Collection<? super T> c, T... elements) {  
            boolean result = false;  
            for (T element : elements)  
                result |= c.add(element);  
            return result;  
        }

**jdk源码 – Arrays.asList(T… a) :**  
从这个内部类ArrayList的实现可以看出，它继承了类AbstractList,但是没有重写add和remove方法，没有给出具体的实现。查看一下AbstractList类中对add和remove方法的定义，如果一个list不支持add和remove就会抛出UnsupportedOperationException。

@SafeVarargs
        @SuppressWarnings("varargs")
        public static <T> List<T> asList(T... a) {
            return new ArrayList<>(a);
        }
    
        /** * @serial include */
        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);
            }
        }

参考:  
[https://stackoverflow.com/questions/1467913/arrays-aslist-not-working-as-it-should][https_stackoverflow.com_questions_1467913_arrays-aslist-not-working-as-it-should]  
[https://blog.csdn.net/bruce128/article/details/21640479][https_blog.csdn.net_bruce128_article_details_21640479]

[https_stackoverflow.com_questions_1467913_arrays-aslist-not-working-as-it-should]: https://stackoverflow.com/questions/1467913/arrays-aslist-not-working-as-it-should
[https_blog.csdn.net_bruce128_article_details_21640479]: https://blog.csdn.net/bruce128/article/details/21640479