笔记总结自公众号

JavaGuide

，感谢Guide哥！

简介


Arrays.asList()

可以将一个数组转化为一个 List 集合

    String[] arr = {"aaa","bbb"};
    List<String> list =  Arrays.asList(arr);
    //上面两行等价于下面一条语句
    List<String> list1 = Arrays.asList("aaa", "bbb");

JDK 源码：

    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

注意事项

传递的数组必须是对象数组，而不是基本类型。


Arrays.asList()

是泛型方法，传入的对象必须是对象数组

    int[] arr1 = {1,2,3};
    List list2 = Arrays.asList(arr1);
    System.out.println(list2.size());  //1
    System.out.println(list2.get(0));  //数组地址值

当传入一个原生数据类型数组时，

Arrays.asList()

真正得到的参数不是数组的元素，而是

数组本身

使用包装类型数组可以解决这个问题：

	Integer[] arr1 = {1,2,3};
    List list2 = Arrays.asList(arr1);
    System.out.println(list2.size());  //3
    System.out.println(list2.get(0));  //1

使用集合的修改方法会抛出异常

    List list = Arrays.asList(1，2，3);
	list.add(4); 
    list.remove(1);
    list.clear();

上述三个方法

add()

、

remove()

、

clear()

均会抛出如下异常，也就意味着用

Arrays.asList()

得到的List的长度是不可改变的

Exception in thread “main” java.lang.UnsupportedOperationException

原因：


Arrays.asList()

方法返回的并不是

java.util.ArrayList

，而是

java.util.Array

的一个内部类，而这个内部类并没有实现集合的修改方法或者说并没有重写这些方法

    List list = Arrays.asList(1,2,3);
    System.out.println(list.getClass()); //class java.util.Arrays$ArrayList

查看

class java.util.Arrays$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) {
       		 //...
        }

        @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) {
            //...
        }

        @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) {
			//...
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
           //...
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

查看它的父类

AbstractList

的源码就会发现

remove()

等方法为什么会抛出异常：

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

如何正确将数组转换为ArrayList ？

最简单的方法：

	List list = new ArrayList<>(Arrays.asList("a","b","c"));

Stream：

	Integer[] arr = {1, 2, 3};
   	List list3 = Arrays.stream(arr).collect(Collectors.toList());
   	//基本类型也可以实现转换,依赖boxed的装箱操作
   	int[] arr1 = {1,2,3};
  	List list4 = Arrays.stream(arr1).boxed().collect(Collectors.toList());