System.arraycopy、Arrays.copyOf和ArrayList的toArray介绍

   1. 先介绍System.arraycopy的用法。以下是官方的文档

arraycopy

public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。从 src 引用的源数组到 dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于 length 参数。源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。

如果参数 src 和 dest 引用相同的数组对象，则复制的执行过程就好像首先将 srcPos 到 srcPos+length-1 位置的组件复制到一个带有 length 组件的临时数组，然后再将此临时数组的内容复制到目标数组的 destPos 到 destPos+length-1 位置一样。

If 如果 dest 为 null，则抛出 NullPointerException 异常。

如果 src 为 null, 则抛出 NullPointerException 异常，并且不会修改目标数组。

否则，只要下列任何情况为真，则抛出 ArrayStoreException 异常并且不会修改目标数组：

• src 参数指的是非数组对象。
• dest 参数指的是非数组对象。
• src 参数和 dest 参数指的是那些其组件类型为不同基本类型的数组。
• src 参数指的是具有基本组件类型的数组且 dest 参数指的是具有引用组件类型的数组。
• src 参数指的是具有引用组件类型的数组且 dest 参数指的是具有基本组件类型的数组。

否则，只要下列任何情况为真，则抛出 IndexOutOfBoundsException 异常，并且不会修改目标数组：

• srcPos 参数为负。
• destPos 参数为负。
• length 参数为负。
• srcPos+length 大于 src.length，即源数组的长度。
• destPos+length 大于 dest.length，即目标数组的长度。

否则，如果源数组中 srcPos 到 srcPos+length-1 位置上的实际组件通过分配转换并不能转换成目标数组的组件类型，则抛出 ArrayStoreException 异常。在这种情况下，将 k 设置为比长度小的最小非负整数，这样就无法将 src[srcPos+k] 转换为目标数组的组件类型；当抛出异常时，从 srcPos 到 srcPos+k-1 位置上的源数组组件已经被复制到目标数组中的 destPos 到 destPos+k-1 位置，而目标数组中的其他位置不会被修改。（因为已经详细说明过的那些限制，只能将此段落有效地应用于两个数组都有引用类型的组件类型的情况。）

参数：

src - 源数组。

srcPos - 源数组中的起始位置。

dest - 目标数组。

destPos - 目标数据中的起始位置。

length - 要复制的数组元素的数量。

抛出：

IndexOutOfBoundsException - 如果复制会导致对数组范围以外的数据的访问。

ArrayStoreException - 如果因为类型不匹配而使得无法将 src 数组中的元素存储到 dest 数组中。

NullPointerException - 如果 src 或 dest 为 null。

那么有个疑问，如果源数组和目标数组类型不一样，可以通过System.arraycopy吗？比如Object的数组可以拷贝到String的数组吗？

    	String[] strArray=new String[5];
    	try{
    	Object[] objArray=new Object[]{"241",5,"sfa",6,"2sd"};
    	System.arraycopy(objArray, 0, strArray, 0, 2);
    	}catch(Exception e){
    		e.printStackTrace();
    		System.out.println(Arrays.toString(strArray));
    	}
    	//output:
//    	java.lang.ArrayStoreException
//    	at java.lang.System.arraycopy(Native Method)
//    	at arrays.AarrysTest.main(AarrysTest.java:34)
//    [241, null, null, null, null]

经过测试后发现，如果源数组存放的对象可以转化为目标数组存放的对象，则可以copy，但是如果不一致，则会抛出ArrayStoreException异常。再次测试代码

package arrays;

import java.util.Arrays;

class Base{
	public int i=0;
	@Override
	public String toString(){
		return "Base"+String.valueOf(i);
	}
}

class Second extends Base{
	@Override
	public String toString(){
		i=2;
		return "Second"+String.valueOf(i);
	}
}

class Thrid extends Second{
	@Override
	public String toString(){
		i=3;
		return "Thrid"+String.valueOf(i);
	}
}

public class AarrysTest {
    public static void main(String[]args){
    	//不同类型的数组arraycopy
    	//目标数组是原数组基类
    	Thrid[] thridarray=new Thrid[2];
    	thridarray[0]=new Thrid();
    	thridarray[1]=new Thrid();
    	Second[] copyarry=new Second[2];
    	System.arraycopy(thridarray, 0, copyarry, 0, 2);
    	System.out.println(Arrays.toString(copyarry));
    	//原数组是目标数组基类
    	Base[] secondarray=new Base[2];
    	secondarray[0]=new Second();
    	secondarray[1]=new Second();
    	System.arraycopy(secondarray, 0, copyarry, 0, 2);
    	System.out.println(Arrays.toString(copyarry));
//    	output:
//    	[Thrid3, Thrid3]
//      [Second2, Second2]

    }
}

2.Arrays.copyOf

查看Arrays.copyOf的源码发现，也是基于System.arraycopy实现的。通过重载实现了基本数据类型数组的复制和引用类型数组的复制。源码如下

   public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        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;
    }

通过传入数组的class，利用反射创建了copy数组，然后使用System.arraycopy将原数组复制到copy数组并返回。原数组的数组类型和copy数组的数组类型可以不一样，比如原数组是Object[],返回的copy数组可以使Integer[]。

基本数据类型数组实现如下

public static byte[] copyOf(byte[] original, int newLength) {
        byte[] copy = new byte[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

3.最好讲一下ArrayList的toArray

由于java泛型使用了擦除实现，所以ArrayList实际存储的是Object的数组，代码也不知道T（返现参数类型）的实际类型，那么如何返回具体参数类型的数组呢？

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

可以看到，如果传入的数组length小于ArrayList的size，则会通过Arrays.copyOf新建一个传入类型的数组并返回。如果大于，则直接使用System.arraycopy将a的0-size-1的数据替换为ArrayList的数据。