List集合转换成数组list.toArray

        List集合转换成集合，List类本身提供了两个api:

Object[] toArray();
<T> T[] toArray(T[] a);

        一个是把集合转换成元素数据类型为Object的数组；另外一个则是一个泛型函数。其中泛型函数这个api是比较常用的，因为它转换后得到的数组的元素类型仍然是列表中的数据元素类型，而不是Object类型。

        在实际使用中，它的用法如下:

List<String> list = new ArrayList<>();
list.add("xxx1");
list.add("xxx2");
list.add("xxx3");
String[] strings = list.toArray(new String[0]);
for (String str : strings) {
    out.println(str);
}

        注意到toArray()函数传入的实参为new String[0]。代表一个数组长度为0的字符串数组。在java中允许数组长度为0。这一点在编写一个结果为数组的方法时，如果碰巧结果为空时，new String[0]这种写法就非常有用了。 在这里我们主要是利用了字符串数组的数据类型信息，并没有实际地开辟一块内存，这样就不会浪费内存了。 那么list.toArray(new String[0])是如何做到传入一个长度为0 的数组，返回的却是list集合的数组形式呢？我们来看这个函数的实现：

/**
 * Returns an array containing all of the elements in this list in
 * proper sequence (from first to last element); the runtime type of
 * the returned array is that of the specified array.  If the list fits
 * in the specified array, it is returned therein.  Otherwise, a new
 * array is allocated with the runtime type of the specified array and
 * the size of this list.
 *
 * <p>If the list fits in the specified array with room to spare (i.e.,
 * the array has more elements than the list), the element in the array
 * immediately following the end of the list is set to <tt>null</tt>.
 * (This is useful in determining the length of the list <i>only</i> if
 * the caller knows that the list does not contain any null elements.)
 *
 * <p>Like the {@link #toArray()} method, this method acts as bridge between
 * array-based and collection-based APIs.  Further, this method allows
 * precise control over the runtime type of the output array, and may,
 * under certain circumstances, be used to save allocation costs.
 *
 * <p>Suppose <tt>x</tt> is a list known to contain only strings.
 * The following code can be used to dump the list into a newly
 * allocated array of <tt>String</tt>:
 *
 * <pre>{@code
 *     String[] y = x.toArray(new String[0]);
 * }</pre>
 *
 * Note that <tt>toArray(new Object[0])</tt> is identical in function to
 * <tt>toArray()</tt>.
 *
 * @param a the array into which the elements of this list are to
 *          be stored, if it is big enough; otherwise, a new array of the
 *          same runtime type is allocated for this purpose.
 * @return an array containing the elements of this list
 * @throws ArrayStoreException if the runtime type of the specified array
 *         is not a supertype of the runtime type of every element in
 *         this list
 * @throws NullPointerException if the specified array is null
 */
<T> T[] toArray(T[] a);

我们来看其在ArrayList上的具体实现：

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

        首先比较形参数组a的数组长度和列表的长度，如果a.length<size，则调用Arrays.copyOf(elementData, size, a.getClass())，其内部实现为：

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

        可以看到其内部会开辟出一块和列表长度一样的数组空间大小，并且数组元素类型和传进来的元素类型一致。调用System.arraycopy()函数进行数组拷贝。

        如果a.length>size,则不需要单独开辟空间了，因为形参的空间足够大了。然后也是调用System.arraycopy()函数进行数组拷贝。最后把形参数组a中剩余空间的值全部赋值为null。

        所以终于解开了List的toArray()函数的面纱了。