数组转集合

我们可以使用Arrays.asList()将一个数组转换为一个 List 集合。

 String[] myArray = {"a", "b", "c"};
 List<String> myList = Arrays.asList(myArray);
 //上面两个语句等价于下面一条语句
 List<String> myList = Arrays.asList("a", "b", "c");

查看asList方法源码：

/**
*返回由指定数组支持的固定大小的列表。此方法结合Collection.toArray，
*充当基于数组和基于集合的api之间的桥梁。返回的列表是可序列化的，
*并实现了RandomAccess。
*/
public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

注意事项：

1、Arrays.asList()是泛型方法，传递的数组必须是对象数组，而不是基本类型。

int[] myArray = {1, 2, 3};
List myList = Arrays.asList(myArray);
System.out.println(myList.size());//1
System.out.println(myList.get(0));//数组地址值  [I@14ae5a5
System.out.println(myList.get(1));//报错：ArrayIndexOutOfBoundsException
int[] array = (int[]) myList.get(0);
System.out.println(array[0]);//1

当传入一个基本数据类型数组时，Arrays.asList() 的真正得到的参数就不是数组中的元素，而是数组对象本身！此时 List 的唯一元素就是这个数组，这也就解释了上面的代码。

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

Integer[] myArray = {1, 2, 3};

2、使用集合的修改方法: add()、remove()、clear()会抛出异常。

List myList = Arrays.asList(1, 2, 3);
myList.add(6);//UnsupportedOperationException
myList.remove(1);//UnsupportedOperationException
myList.clear();//UnsupportedOperationException

Arrays.asList() 方法返回的并不是 java.util.ArrayList ，而是 java.util.Arrays 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。

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

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) {
            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);
        }
    }

再看一下java.util.AbstractList的 add/remove/clear 方法就知道为什么会抛出 UnsupportedOperationException 了。

 public boolean add(E e) {
        add(size(), e);
        return true;
 }

public void add(int index, E element) {
        throw new UnsupportedOperationException();
}  
      
 public E remove(int index) {
     throw new UnsupportedOperationException();
 }
 
 public void clear() {
        removeRange(0, size());
 }

protected void removeRange(int fromIndex, int toIndex) {
        ListIterator<E> it = listIterator(fromIndex);
        for (int i=0, n=toIndex-fromIndex; i<n; i++) {
            it.next();
            it.remove();
        }
 }

那么如何正确的将数组转换为 ArrayList ?

最简单的方式：

List list = new ArrayList<>(Arrays.asList("a","b","c"));
System.out.println(list.getClass());  //class java.util.ArrayList

使用 Java8 的 Stream(推荐)

Integer [] myArray = {1, 2, 3};
List myList = Arrays.stream(myArray).collect(Collectors.toList());
System.out.println(myList.getClass()); //class java.util.ArrayList

//基本类型也可以实现转换（依赖boxed的装箱操作）
int [] myArray1 = {1, 2, 3};
List myList = Arrays.stream(myArray1).boxed().collect(Collectors.toList());
System.out.println(myList.getClass()); //class java.util.ArrayList