<!--more-->
int[] a = {1, 2, 3, 4, 5};
?
// 創(chuàng)建新數組，長度為源數組的兩倍
int[] b = new int[a.length * 2];
?
// 將舊數組內容復制到新數組
for (int i = 0; i < a.length; i++) {
? ? b[i] = a[i];
}
?
// 新數組內容賦值給源數組
a = b;
?
// 打印結果
System.out.println(Arrays.toString(a));

int[] a = {1, 2, 3, 4, 5};
?
// 第一個參數是拷貝的數組，第二個參數是擴容長度，且返回一個新數組
a = Arrays.copyOf(a, a.length * 2);
?
// 打印結果
System.out.println(Arrays.toString(a));

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

int[] a = {1, 2, 3, 4, 5};
?
// 定義新數組，長度為源數組的兩倍
int[] b = new int[a.length * 2];
?
/**
 * src      需要拷貝的源數組
 * srcPos   源數組中的起始位置
 * dest     目標數組
 * destPos  目標數組中的起始位置
 * length   要復制的數組元素數量
 */
System.arraycopy(a, 0, b, 0, a.length);
?
// 新數組內容賦值給原數組
a = b;
?
// 打印結果
System.out.println(Arrays.toString(a));

/**
     * @param src     the source array.  源數組
     * @param srcPos  starting position in the source array. 要復制的源數組的起始位置
     * @param dest    the destination array. 目標數組
     * @param destPos starting position in the destination data. 目標數組的起始位置
     * @param length  the number of array elements to be copied. 要復制的長度
     * @throws IndexOutOfBoundsException if copying would cause
     *                                   access of data outside array bounds.
     *                                   如果復制會導致數據的訪問超出數組邊界。
     *                                   則會報IndexOutOfBoundsException索引越界異常
     * @throws ArrayStoreException       if an element in the <code>src</code> array
     *                                   could not be stored into the 
                                         <code>dest</code> array
     *                                   because of a type mismatch.
     *                                   如果由于類型不匹配而無法將src數組中的元素存儲到dest數組中。
     *                                   則會報 ArrayStoreException數組存儲異常
     * @throws NullPointerException      if either <code>src</code> or
     *                                   <code>dest</code> is <code>null</code>.
     *                                   如果src或dest為null。
     *                                   則會報NullPointerException空指針異常
     */
?
    public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

//從舊數組拷貝到新數組
for (int i=0;i<size;i++){
    arrayNew[i]=array[i];
}
System.arraycopy(array, 0, arrayNew, 0, array.length);

//從左向右循環(huán)，逐個元素向左挪一位。
for (int i = index; i < size - 1; i++) {
    array[i] = array[i + 1];
}
System.arraycopy(array, index + 1, array, index, size - 1 - index);

//從右向左循環(huán)，逐個元素向右挪一位。
for (int i = size - 1; i >= index; i--) {
    array[i + 1] = array[i];
}
System.arraycopy(array, index, array, index + 1, size - index);

public class SystemArrayCopyTestCase {
?
    public static void main(String[] args) {
        User[] users = new User[] { 
                new User(1), 
                new User(2),
                new User(3) };// 初始化對象數組
        User[] target = new User[users.length];// 新建一個目標對象數組
        System.arraycopy(users, 0, target, 0, users.length);// 實現復制
        System.out.println("源對象與目標對象的物理地址是否一樣：" + (users[0] == target[0] ? "淺復制" : "深復制"));  //淺復制
        target[0].setId(5);
        System.out.println("修改目標對象的屬性值后源對象users：");
        for (User user : users) {
            System.out.println(user);
        }
    }
}
?
class User {
}
?

public class ArrayCopyThreadSafe {
    private static int[] arrayOriginal = new int[1024 * 1024 * 10];
    private static int[] arraySrc = new int[1024 * 1024 * 10];
    private static int[] arrayDist = new int[1024 * 1024 * 10];
    private static ReentrantLock lock = new ReentrantLock();
?
    private static void modify() {
        for (int i = 0; i < arraySrc.length; i++) {
            arraySrc[i] = i + 1;
        }
    }
?
    private static void copy() {
        System.arraycopy(arraySrc, 0, arrayDist, 0, arraySrc.length);
    }
?
    private static void init() {
        for (int i = 0; i < arraySrc.length; i++) {
            arrayOriginal[i] = i;
            arraySrc[i] = i;
            arrayDist[i] = 0;
        }
    }
?
    private static void doThreadSafeCheck() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("run count: " + (i + 1));
            init();
            Condition condition = lock.newCondition();
?
            new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
                    condition.signalAll();
                    lock.unlock();
                    copy();
                }
            }).start();
?
?
            lock.lock();
            // 這里使用 Condition 來保證拷貝線程先已經運行了.
            condition.await();
            lock.unlock();
?
            Thread.sleep(2); // 休眠2毫秒, 確?？截惒僮饕呀泩?zhí)行了, 才執(zhí)行修改操作.
            modify();
?
            if (!Arrays.equals(arrayOriginal, arrayDist)) {
                throw new RuntimeException("System.arraycopy is not thread safe");
            }
        }
    }
?
    public static void main(String[] args) throws Exception {
        doThreadSafeCheck();
    }
}
?