Arrays

java version “1.8.0_131”

一、总结

• 数组工具类，私有构造方法，提供静态方法
• Arrays.asList()与相应集合的toArray()方法实现List与Array 之间的互相转化；如：ArrayList.toArray

二、源码分析

1. asList()

将数组转化为集合

    /**     * Returns a fixed-size list backed by the specified array.  (Changes to     * the returned list "write through" to the array.)  This method acts     * as bridge between array-based and collection-based APIs, in     * combination with {@link Collection#toArray}.  The returned list is     * serializable and implements {@link RandomAccess}.     *     * <p>This method also provides a convenient way to create a fixed-size     * list initialized to contain several elements:     * <pre>     *     List&lt;String&gt; stooges = Arrays.asList("Larry", "Moe", "Curly");     * </pre>     *     * @param <T> the class of the objects in the array     * @param a the array by which the list will be backed     * @return a list view of the specified array     */    @SafeVarargs    @SuppressWarnings("varargs")    public static <T> List<T> asList(T... a) {        return new ArrayList<>(a);    }

注释

• 返回由指定数组支持的固定大小的List集合。
• 将写入的array 改为返回的集合List
• Arrays.asList() 与 Collection.toArray() 是List 与 Array 相互转化的桥梁
• 返回值 List 实现了序列化 Serializable 与 RandomAccess 接口
• asList 方法允许同时传入多个参数

总结

• asList()只是将Array转为List，数组的大小、内容均为改变
• 此处返回的ArrayList不是java.util.ArrayList，而是Arrays.ArrayList即Arrays内部的私有静态内部类。
• T 泛型，Type , 表示Java类

问题

• 为什么Arrays要再次实现ArrayList，而不直接使用java.util.ArrayList?
  从asList()方法的注释上得知，该方法只是将传入的Array转为List而保持内容及大小不变，即只读，不提供扩展、删除方法，所以重新定义了一个ArrayList
• 为什么返回值可以使用List接收？因为Arrays.ArrayList 继承了 AbstractList，而 AbstractList 实现了 List 接口，即 Arrays.ArrayList间接实现了 List
• 为什么使用泛型T而不是用Object？因为Object虽然是所有类的父类，但使用过程需伴随着类型的强制转换，如果类型没有对应上，则会抛出转化异常；使用泛型的话，在调用方法前类型就已经确认，无需进行类型转换

注意

• 基本数据类型数据与基本数据类型的包装类的数组的区别

    // 对比基本数据类型数组、包装类数据类型数组转化后的结果    public static void main(String[] args) {        int [] intArray = new int[]{1,2,3,4};        List<int[]> asList = Arrays.asList(intArray);        System.out.println(asList.size()); // 1         Integer [] integerArray = new Integer[]{1,2,3,4};        List<Integer> asList2 = Arrays.asList(integerArray);        System.out.println(asList2.size()); // 4    }

结果分析

• 小技巧：快速生成方法的返回值，IDE为Eclipse，将鼠标放在方法的尾部，ctrl+1，根据提示选择第一项，assign statement to new local variable ; 或者 在方法前ctrl+2 , 再按L ；自动添加方法的返回值
• asList()方法的参数为T 多个泛型T ，而基本数据类型不是泛型，int[] 整体作为泛型，索引参数为 基本类型数组时，asList()返回的List的长度为1
• asList()方法的参数为包装类数组时，包装类即引用数据类型，即多个泛型作为参数，返回的list的长度为数组的length

---

• asList()方法的返回值是List，实质是return new ArrayList()，此ArrayList是Arrays内部私有静态类，是为了实现 asList() 返回与传入的数组的大小相同的List而定义；不支持add()、remove()等改变数组大小的方法；但List中有这些方法，即可以调用；如果调用的话，会抛出异常 java.lang.UnsupportedOperationException。分析调用过程：

        // asList 可接收多个参数作为入参        List<Integer> asList3 = Arrays.asList(1,2,3,4);        // 调用list中的remove        asList3.remove(1);         // 调用AbstractList 类中的 remove()        // 因为AbstractList 实现了 List,而ArrayList继承了AbstractList        // AbstractList中remove()定义如下        // 由于ArrayList继承AbstractList时未重写该方法，所以List.remove 时调用父类中的方法，故抛出该异常            /**     * {@inheritDoc}     *     * <p>This implementation always throws an     * {@code UnsupportedOperationException}.     *     * @throws UnsupportedOperationException {@inheritDoc}     * @throws IndexOutOfBoundsException     {@inheritDoc}     */    public E remove(int index) {    throw new UnsupportedOperationException();    }    // 如果想调用 add() remove() 等方法    List<Integer> asList4 = new ArrayList<Integer>(asList3);    asList4.remove(1);

结论

• asList()返回值list，不可调用 add()、remove()，会抛出异常
• 如果想调用 add()、remove()，将其作为参数放入java.util.ArrayList中

2. ArrayList

    /**     * @serial include     */    private static class ArrayList<E> extends AbstractList<E>        implements RandomAccess, java.io.Serializable    {        private static final long serialVersionUID = -2764017481108945198L;        // 类的私有属性        // E  泛型，表示集合中的元素        // ArrayList  的底层是数组，同 java.util.ArrayList        // 不同的是 java.util.ArrayList 中是 Object[] elementData        // 而此处是 泛型E 的数组        private final E[] a;        ArrayList(E[] array) {            // 此处调用 Objects 中判空的方法，如果 array 为空，抛出 NullPointerException            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);        }    }

类

• 私有的内部静态类
• 继承 AbstractList ，作用：实现了List接口，减少子类在实现List接口需要实现的方法的数量
• 实现 RandomAccess ，作用：标识该集合为顺序表，遍历时最好使用for循环遍历，相对应的，如果是LinkedList，遍历时最好使用 iterator 迭代器方式；在大量数据的集合时性能最优
• 实现 java.io.Serializable ，作用：类声明的对象可序列化为一个字节序列，保存对象的状态
• E 泛型，Element ，代表集合中的元素

Arrays.ArrayList 与 java.util.ArrayList的异同

• 数据结构均为数组，前者是 E[] 泛型数组；后者为 Object[] 类型数组；前者使用时无需进行数据类型的转换
• 构造方法：若参数为null，前者若泛型集合为null，抛出NPE（null point exception）;后者同样会抛出异常，elementData = c.toArray(); 时抛出 NPE异常。

        /**         * Arrays.ArrayList 构造方法抛出空指针示例         */        Integer [] integerArray4 = null;        // 此处抛出NPE异常        List<Integer> asList6 = Arrays.asList(integerArray4);        System.out.println(asList6);        int [] intArray1 = null ;        // 此处运行正常        // 原因：int [] 整体作为泛型，null 为 E[] 中的元素，非空        List<int[]> asList5 = Arrays.asList(intArray1);        System.out.println(asList5); // 输出 [null]

3.copyOf()

    /**     * Copies the specified array, truncating or padding with nulls (if necessary)     * so the copy has the specified length.  For all indices that are     * valid in both the original array and the copy, the two arrays will     * contain identical values.  For any indices that are valid in the     * copy but not the original, the copy will contain <tt>null</tt>.     * Such indices will exist if and only if the specified length     * is greater than that of the original array.     * The resulting array is of exactly the same class as the original array.     *     * @param original the array to be copied     * @param newLength the length of the copy to be returned     * @return a copy of the original array, truncated or padded with nulls     *     to obtain the specified length     * @throws NegativeArraySizeException if <tt>newLength</tt> is negative     * @throws NullPointerException if <tt>original</tt> is null     * @since 1.6     */    public static <T> T[] copyOf(T[] original, int newLength) {        return (T[]) copyOf(original, newLength, original.getClass());    }    /**     * Copies the specified array, truncating or padding with nulls (if necessary)     * so the copy has the specified length.  For all indices that are     * valid in both the original array and the copy, the two arrays will     * contain identical values.  For any indices that are valid in the     * copy but not the original, the copy will contain <tt>null</tt>.     * Such indices will exist if and only if the specified length     * is greater than that of the original array.     * The resulting array is of the class <tt>newType</tt>.     *     * @param original the array to be copied     * @param newLength the length of the copy to be returned     * @param newType the class of the copy to be returned     * @return a copy of the original array, truncated or padded with nulls     *     to obtain the specified length     * @throws NegativeArraySizeException if <tt>newLength</tt> is negative     * @throws NullPointerException if <tt>original</tt> is null     * @throws ArrayStoreException if an element copied from     *     <tt>original</tt> is not of a runtime type that can be stored in     *     an array of class <tt>newType</tt>     * @since 1.6     */    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {        // 判断新的数据类型是否是Object[]        T[] copy = ((Object)newType == (Object)Object[].class)            ? (T[]) new Object[newLength]            : (T[])         // 若不是Object[]类型重新生成一个新的数组，类型为T            Array.newInstance(newType.getComponentType(), newLength);        // 调用System 中的Native 方法进行数组copy        // 从 original 的 0 位置开始，向 copy 的 0 位置，复制元素，长度为 新旧数组的最小长度        System.arraycopy(original, 0, copy, 0,                         Math.min(original.length, newLength));        return copy;    }