toArray方法总结

大家好，又见面了，我是你们的朋友全栈君。

toArray方法涉及java的泛型，反射，数组的协变，jvm等知识。

Java标准库中Collection接口定义了toArray方法，如果传入参数为空，则返回Object[]数组，如果传入参数为T[]，则返回参数为传入参数的运行时类型。以下是ArrayList的实现：

// 略去无关内容
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
}

1. 传入的静态参数T为编译器提供了编译器检查，如果类型不匹配，则编译不通过。

如test1所示，Byd[] 不能接受静态返回类型Brand[]，除非作类型强转，才可以编译通过，但是会报运行时类型转换异常。这个异常非常有意思，虽然方法返回的数组类型为Brand[]，并且其中的每个元素都为Byd，但是Brand[]类型不能强转为Byd[]类型。根本原因是JVM的限制，即不能对运行时数组类型进行强转。如test3所示，cmps的静态类型是Comparable[]，运行时类型是Integer[],运行时类型不能转化。

类型转换中向上转型是支持的（转型为父类或接口），向下转型必须进行类型强转，可能报运行时异常。java中数组支持协变，即Byd[]是Brand[]的子类，可以用Brand[]类型接收Byd[]对象，如test4所示。

test6也很有意思，虽然List<Brand>转化为了Brand[]，编译通过，但是由于传入的Byd[]为brands1的运行时类型，在往实际的Byd[]中存放Brand的过程中，会报ArrayStoreException异常，由于Java支持数组协变，这种运行时异常无法在编译期检查出来。最简单的例子见如下源码注释：

此时在运行时抛出了数组存储异常，因为数组的实际类型为String[]，虚拟机运行时进行类型检查发现类型不匹配就抛出此异常。

 数组对象的底层数据存储如上图所示，对象头中Mark Word存储hashCode和内存回收、并发相关信息，Klass Word为类型指针，存储类型不匹配抛出ArrayStoreException，array length为数组长度，数组越界抛出ArrayIndexOutOfBoundsException。

interface Brand {
    int getId();
    String getBrandName();
}

@Data
@AllArgsConstructor
class Byd implements Brand {
    int id;
    String brandName;
    Integer speed;
}

@Data
@AllArgsConstructor
class Tesla implements Brand {
    int id;
    String brandName;
}

public class ArraysTest {
    @Test
    public void test1() {
        List<Byd> byds = new ArrayList<>();
        byds.add(new Byd(1, "唐", 100));
        byds.add(new Byd(2, "宋", 120));
        // Byd[] byds1 = byds.toArray(new Brand[0]);
        // 传入参数类型Brand[]和返回参数类型不匹配, 不能编译通过

        Byd[] byds1 = (Byd[]) byds.toArray(new Brand[0]);
        // 编译通过，报运行时异常：
        // java.lang.ClassCastException: [Lcom.dahua.Brand; cannot be cast to [Lcom.dahua.Byd;
    }

    @Test
    public void test2() {
        List<Byd> byds = new ArrayList<>();
        byds.add(new Byd(1, "唐", 100));
        byds.add(new Byd(2, "宋", 120));
        Brand[] brands = byds.toArray(new Byd[0]);
        System.out.println(Arrays.toString(brands));
        // 输出：
        // [Byd(id=1, brandName=唐, speed=100), Byd(id=2, brandName=宋, speed=120)]
    }

    @Test
    public void test3() {
        Integer[] ints = new Integer[3];
        Arrays.setAll(ints, x -> x+1);
        Comparable[] cmps = (Comparable[]) ints;
        System.out.println(cmps.getClass().getComponentType());
        // 输出：
        // class java.lang.Integer
    }

    @Test
    public void test4() {
        List<Byd> byds = new ArrayList<>();
        byds.add(new Byd(1, "唐", 100));
        byds.add(new Byd(2, "宋", 120));
        Brand[] brands = byds.toArray(new Byd[0]);
        System.out.println(brands.getClass().getComponentType());
        // 输出：
        // class com.dahua.Byd
    }

    @Test
    public void test5() {
        List<Brand> brands = new ArrayList<>();
        brands.add(new Byd(1, "唐", 100));
        brands.add(new Byd(2, "宋", 120));
        Brand[] brands1 = brands.toArray(new Byd[0]);
        System.out.println(brands1.getClass().getComponentType());
        // 输出：
        // class com.dahua.Byd
    }

    @Test
    public void test6() {
        List<Brand> brands = new ArrayList<>();
        brands.add(new Byd(1, "唐", 100));
        brands.add(new Byd(2, "宋", 120));
        brands.add(new Tesla(3, "model S"));
        Brand[] brands1 = brands.toArray(new Byd[0]);
        // 编译通过， 但是运行时异常：
        // java.lang.ArrayStoreException
    }
}

 2. 如果toArray方法传入的数组长度大于等于list的size，只将size后一个位置置空。由于ArrayList::toArray方法通常传入长度为0的数组，调用了Arrys::copyOf方法，下面来看此方法。

public class Arrays {    
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
}

首先创建copy对象，其类型只能在运行时指定，Array::newInstance可以在运行时创建数组，动态指定类型。

1. 泛型T U可以用作静态类型检查，如test7所示，传入的Double[].class，其返回值可以由Comparable[]接收，只要newType代表的静态类型为T[]的子类即可，Double[]是Comparable[]的子类，虽然静态类型检查通过，但是运行期异常报出。
2. 如果传入raw类型（不带泛型的Class）,依然可以通过编译，这是java为了前向兼容非泛型类型。此时返回类型为Object[],实际上此方法的字节码返回的也是Object[]。建议使用带泛型的形式。
3. 对于不安全的类型转换编译器会报unchecked 警告，表示编译器无法做类型检查。对于确定安全的方法，使用@SuppressWarnings关闭。对于编译器报unchecked警告需要提高警惕，此处极有可能遇到bug问题。
4. System.arraycopy为native方法，在内存中对数组进行复制，效率更高。

    @Test
    public void test7() {
        Integer[] ints = new Integer[10];
        Arrays.setAll(ints, x -> x+1);
//        Comparable[] comparables = Arrays.copyOf(ints, 5, Double[].class);
        // 编译通过，运行时异常

        Class clazz = Object[].class;
        System.out.println(clazz);

        Object[] arr = Arrays.copyOf(ints, 4, clazz);
        System.out.println(Arrays.toString(arr));

//        clazz = Number[].class;
//        Number[] objects = Arrays.copyOf(ints, 5, clazz);
        // 无法编译，类型不匹配
    }

通过以上分析，对于LinkedList的分析就简单了。

// 遍历复制
public Object[] toArray() {
    Object[] result = new Object[size];
    int i = 0;
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;
    return result;
}


// 运行时创建数组，遍历复制
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            a = (T[])java.lang.reflect.Array.newInstance(
                                a.getClass().getComponentType(), size);
        int i = 0;
        Object[] result = a;
        for (Node<E> x = first; x != null; x = x.next)
            result[i++] = x.item;

        if (a.length > size)
            a[size] = null;

        return a;
    }

// 注意：toArray方法没有对List<E>泛型类型E和数组类型进行校验，所以便有如下测试结果。

    // 可以通过编译，运行通过
    @Test
    public void test9() {
        List<Integer> list = new LinkedList<>();
        Double[] list2 = list.toArray(new Double[0]);
        for (Double d : list2) {
            System.out.println(d);
        }
    }

    // 编译通过，运行异常
    @Test
    public void test10() {
        List<Integer> list = new LinkedList<>();
        list.add(1);
        Double[] list2 = list.toArray(new Double[0]);
        // java.lang.ArrayStoreException: java.lang.Integer
        for (Double d : list2) {
            System.out.println(d);
        }
    }

总结：

1. 由于数组编译时需要“物化”类型，而泛型在Java运行时已经擦除为Object、上界（extends）、上界（extends），不能确定具体的类型，编译器不通过。如果需要在运行时确定数组类型并创建数组，需要调用Array.newInstance方法，传入泛型类型参数。

2. 使用时尽量带上泛型参数，便于编译期检查类型。

3. 注意@SuppressWarnings(“unchecked”)方法使用时可能会有运行时异常，应该小心使用此类方法。