描述

public static int[] copyOf(int[] original,int newLength)
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

作用

Arrays.copyOf()方法返回原始陣列的副本，用零截斷或填充以獲取指定的長度。
System.arraycopy()方法複製指定的源陣列的陣列，在指定的位置開始，到目標陣列的指定位置。

引數

copyOf()引數

• original - 這是要複製的陣列
• newLength - 這是要返回的副本的長度

arraycopy()引數

• Object src : 原陣列
• int srcPos : 從元資料的起始位置開始
• Object dest : 目標陣列
• int destPos : 目標陣列的開始起始位置
• int length : 要copy的陣列的長度

程式碼

測試環境

JDK 10

測試copyOf

    int arr1[] = { 0, 1, 2, 3, 4, 5 };
    int arr2[] = { 5, 10, 20, 30, 40, 50 };
    System.out.println("array = "
 
 + Arrays.toString(Arrays.copyOf(arr2, 3)));
    System.out.println("array = " + Arrays.toString(Arrays.copyOf(arr2, 7)));
    System.out.println(System.getProperty("java.version"));
    // 10.0.1

輸出 :
- array = [5, 10, 20]
- array = [5, 10, 20, 30, 40, 50, 0]
- 10.0.1

測試arraycopy

    int arr0[] = { 10
 
, 11, 12, 13, 14, 15 };
    int arr1[] = { 0, 1, 2, 3, 4, 5 };
    int arr2[] = { 5, 10, 20, 30, 40, 50 };

    // 將arr0中0開始共三位（0-2）複製到arr1中從0開始往後數3位
    System.arraycopy(arr0, 0, arr1, 0, 3);
    // 將arr2中0-5的數字用arr0中的前六位替換
    System.arraycopy(arr0, 0, arr2, 0, 6);

    // System.arraycopy(arr0, 0, arr2, 0, 8);
    // java.lang.ArrayIndexOutOfBoundsException

    System.out.println("array0 = " + Arrays.toString(arr0));
    System.out.println("array1 = " + Arrays.toString(arr1));
    System.out.println("array2 = " + Arrays.toString(arr2));
    System.out.println(System.getProperty("java.version"));

    /*
     * array0 = [10, 11, 12, 13, 14, 15] 
     * array1 = [10, 11, 12, 3, 4, 5] 
     * array2 = [10, 11, 12, 13, 14, 15] 
     * 10.0.1
     */

比較

copyOf原始碼

    /**
     * Copies the specified array, truncating or padding with zeros (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>0</tt>.
     複製但不是原件，副本將包含<tt> 0 </ tt>。
     當且僅當指定長度時，此類指數才會存在
     大於原始陣列的值。
     * Such indices will exist if and only if the specified length
     * is greater than that of 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 zeros
     *     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 int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

測試程式碼

package fortest;

public class test {

    public static void main(String[] args) {
        testArrayCopyBytes();
        System.out.println(System.getProperty("java.version"));
        // - 10.0.1
    }

    public static void testHardCopyBytes() {
        byte[] bytes = new byte[0x5000000]; /* ~83mb buffer */
        byte[] out = new byte[bytes.length];
        for (int i = 0; i < out.length; i++) {
            out[i] = bytes[i];
        }
    }

    public static void testArrayCopyBytes() {
        // 虛擬碼
        long startTime = System.nanoTime(); // 獲取開始時間
        testHardCopyBytes();
        long endTime = System.nanoTime(); // 獲取結束時間
        System.out.println("程式執行時間： " + (endTime - startTime) + "ns");

        startTime = System.nanoTime();
        byte[] bytes = new byte[0x5000000]; /* ~83mb buffer */
        byte[] out = new byte[bytes.length];
        System.arraycopy(bytes, 0, out, 0, out.length);
        endTime = System.nanoTime();
        System.out.println("程式執行時間： " + (endTime - startTime) + "ns");

        // 第一次 ： 
        // 程式執行時間： 170478773ns 
        // 程式執行時間： 114007147ns

        // 第二次 ： 
        // 程式執行時間： 216062557ns 
        // 程式執行時間：  96864355ns

        // 第三次 ： 
        // 程式執行時間： 172299936ns 
        // 程式執行時間： 109810835ns

        // 第四次 ： 
        // 程式執行時間： 170478773ns 
        // 程式執行時間： 114007147ns

    }
}

總結

1. System.arraycopy() 比 Arrays.copyOf()更有優勢，節省了定址時間