System.arraycopy基础用法详解

Copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array. A subsequence of array components are copied from the source array referenced by src to the destination array referenced by dest. The number of components copied is equal to the length argument. The components at positions srcPos through srcPos+length-1 in the source array are copied into positions destPos through destPos+length-1, respectively, of the destination array.
If the src and dest arguments refer to the same array object, then the copying is performed as if the components at positions srcPos through srcPos+length-1 were first copied to a temporary array with length components and then the contents of the temporary array were copied into positions destPos through destPos+length-1 of the destination array.
If dest is null, then a NullPointerException is thrown.
If src is null, then a NullPointerException is thrown and the destination array is not modified.
Otherwise, if any of the following is true, an ArrayStoreException is thrown and the destination is not modified:
The src argument refers to an object that is not an array.
The dest argument refers to an object that is not an array.
The src argument and dest argument refer to arrays whose component types are different primitive types.
The src argument refers to an array with a primitive component type and the dest argument refers to an array with a reference component type.
The src argument refers to an array with a reference component type and the dest argument refers to an array with a primitive component type.
Otherwise, if any of the following is true, an IndexOutOfBoundsException is thrown and the destination is not modified:
The srcPos argument is negative.
The destPos argument is negative.
The length argument is negative.
srcPos+length is greater than src.length, the length of the source array.
destPos+length is greater than dest.length, the length of the destination array.
Otherwise, if any actual component of the source array from position srcPos through srcPos+length-1 cannot be converted to the component type of the destination array by assignment conversion, an ArrayStoreException is thrown. In this case, let k be the smallest nonnegative integer less than length such that src[srcPos+k] cannot be converted to the component type of the destination array; when the exception is thrown, source array components from positions srcPos through srcPos+k-1 will already have been copied to destination array positions destPos through destPos+k-1 and no other positions of the destination array will have been modified. (Because of the restrictions already itemized, this paragraph effectively applies only to the situation where both arrays have component types that are reference types.)
Params:
src – the source array.
srcPos – starting position in the source array.
dest – the destination array.
destPos – starting position in the destination data.
length – the number of array elements to be copied.
Throws:
IndexOutOfBoundsException – if copying would cause access of data outside array bounds.
ArrayStoreException – if an element in the src array could not be stored into the dest array because of a type mismatch.
NullPointerException – if either src or dest is null.

@HotSpotIntrinsicCandidate
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

1. 通过源码的解释，Object src 是原数组，srcPos是原数组的起始位置，Object dest 是目标数组，int destPos 是目标数组，int length 是要复制的长度。
2. 源码原译：从指定的源数组（从指定位置开始）复制数组到目标数组的指定位置。 数组组件的子序列从src引用的源数组复制到dest引用的目标数组。 复制的组件数等于length参数。 在位置的部件srcPos通过srcPos+length-1的源阵列中的被复制到的位置destPos通过destPos+length-1分别，目标数组的。
   如果src和dest参数引用相同的数组对象，则执行复制，就好像srcPos到srcPos+length-1位置上的分量复制到具有length分量的临时数组，然后将临时数组的内容通过目标数组的destPos+length-1复制到位置destPos 。

  用代码来进行演示:

       int[] oldNum= new int[10];
       int[] newNum= new int[oldNum.length];
       //初始化数组
        for(int i =0;i<oldNum.length;i++){
            oldNum[i]=i;
        }
        System.arraycopy(oldNum,0,newNum,0,oldNum.length);
        for(int i : newNum){
            System.out.print(i); //0123456789
        }

        System.arraycopy(oldNum,1,newNum,2,5);
        for(int i : newNum){
            System.out.print(i); //0012345000
        }

1. 从上面代码可以看出int length 是直接从1开始进行计算，而srcPos，destPos 是从0开始计算的。
2. 如果数组范围较小的时候，for循环替换和arraycopy的时间是相差无几的，而数组范围过大时间会相差过大

        int[] oldNum = new int[1000000];
        int[] newNum = new int[oldNum.length];
        //初始化数组
        for (int i = 0; i < oldNum.length; i++) {
            oldNum[i] = i;
        }
        long forStartTime = System.currentTimeMillis();
        for (int i = 0; i < oldNum.length; i++) {
            newNum[i] = newNum[i];
        }
        long forEndTime = System.currentTimeMillis();
        System.out.println("for循环时间:" + (forEndTime - forStartTime));
        long systemStartTime = System.currentTimeMillis();
        System.arraycopy(oldNum,0,newNum,0,oldNum.length);
        long systemEndTime = System.currentTimeMillis();
        System.out.println("arraycopy循环时间:" + (systemEndTime - systemStartTime));

        
        得出的结果:

        for循环时间:2
        arraycopy循环时间:1


     

• 看结果可以得出数组范围过大的话，arraycopy速度比for循环更快，省去for循环过程中找地址的时间，提高了替换的效能