深入解析Java数组转集合Arrays.asList()方法

String[] tem = {"aa","bb","cc"};
List<String> list = Arrays.asList(tem);
System.out.println(list.get(1));// bb
System.out.println(list.add("dd"));// 报错 java.lang.UnsupportedOperationException

在使用Arrays.asList()方法将数组转为集合后，调用集合的get()方法没有问题，但是add()方法就报错了。
这是因为Arrays.asList()返回的是Arrays的内部类，这个内部类并没有实现集合的一些相关方法

Arrays相关源码如下：

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

    /**
     * @serial include  上面的asList()方法中new的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);
        }
    }

    ......

}

所以并不能将通过Arrays.asList()方法的来的集合当作一个真正的集合来使用，其底层其实还是数组。 体现的是适配器模式，只是转换接口。
并且使用Arrays.asList()方法来转换数组，分两种情况：

1.基础数据类型数组

int[] num = {1,2,3,4};
List list = Arrays.asList(num);
list.get(0);// 返回的是数组地址值
list.get(1);// 报错，下标越界
list.add(1);// 报错  java.lang.UnsupportedOperationException

当把基础数据类型的数组转为集合时，实际上是将这个数组存入了Arrays的内部类ArrayList中的E[]数组中。
当传入一个原生数据类型数组时，Arrays.asList()的真正得到的参数就不是数组中的元素，而是数组对象本身！
此时List的唯一元素就是这个数组，这也就解释了上面的代码。
结合Arrays的源码可知，也就是a的值为[[1,2,3,4,]]。
所以调用get()方法时，当下标大于0就会报下标越界错误。
同时该内部类没有实现add()方法，会报错，为什么会报 java.lang.UnsupportedOperationException？
看下这个内部类继承的这个AbstractList类的源码：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

   ......
   
   /**
   * {@inheritDoc}
   *
   * <p>This implementation always throws an
   * {@code UnsupportedOperationException}.
   *
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException            {@inheritDoc}
   * @throws NullPointerException          {@inheritDoc}
   * @throws IllegalArgumentException      {@inheritDoc}
   * @throws IndexOutOfBoundsException     {@inheritDoc}
   */
  public void add(int index, E element) {
      throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   *
   * <p>This implementation always throws an
   * {@code UnsupportedOperationException}.
   *
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws IndexOutOfBoundsException     {@inheritDoc}
   */
  public E remove(int index) {
      throw new UnsupportedOperationException();
  }
 
  ......
 
}

2.引用对象类型数组

Integer[] tem = {1,2,3,4};
List list = Arrays.asList(tem);
list.get(1);// 2
list.add(5);// 报错java.lang.UnsupportedOperationException

使用基础数据类型的包装类或其他引用对象数组，传入到内部类的就是数组中的元素。
也就是a的值为[1,2,3,4]。
内部类中已经重写的方法，list都可以像集合般使用，如get(),set()等。
未重写的方法，如add()等，会报UnsupportedOperationException异常。

注意：基础数据数组和引用对象数组使用Arrays.asList()方法都有一个问题，即原数组会对转换后的集合产生影响

Integer[] a = {1,2,3,4};
List<Integer> b = Arrays.asList(a);
System.out.println(b.get(2)); // 3
a[2] = 5;
System.out.println(b.get(2)); // 5

《阿里巴巴Java开发手册》对该方法有如下描述

那么怎么正确的将数组转为集合了？

1.自己手动实现

通过for循环遍历数组将其转为集合

2.简便方法(引用对象数组)

Integer[] a = {1,2,3,4};
List b = new ArrayList<>(Arrays.asList(a));
System.out.println(b.get(2)); //3
a[2] = 5;
b.set(3, 7);
b.add(9);
System.out.println(b.get(2)); //3
System.out.println(b.get(3)); //7
System.out.println(b); // [1,2,3,7,9]

3.使用 Java8 的Stream(推荐)

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

4.使用 Java9 的 List.of()方法

Integer[] array = {1, 2, 3};
List<Integer> list = List.of(array);
System.out.println(list); /* [1, 2, 3] */
/* 不支持基本数据类型 */

附：集合转数组

List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
Integer[] array = list.toArray(new Integer[0]);  //没有指定类型的话会报错

由于JVM优化，new String[0]作为Collection.toArray()方法的参数现在使用更好，new String[0]就是起一个模板的作用，指定了返回数组的类型，0是为了节省空间，因为它只是为了说明返回的类型。