Java数组扩容的三大小结

<!--more-->
int[] a = {1, 2, 3, 4, 5};
​
// 创建新数组，长度为源数组的两倍
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);

//从左向右循环，逐个元素向左挪一位。
for (int i = index; i < size - 1; i++) {
    array[i] = array[i + 1];
}
System.arraycopy(array, index + 1, array, index, size - 1 - index);

//从右向左循环，逐个元素向右挪一位。
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毫秒, 确保拷贝操作已经执行了, 才执行修改操作.
            modify();
​
            if (!Arrays.equals(arrayOriginal, arrayDist)) {
                throw new RuntimeException("System.arraycopy is not thread safe");
            }
        }
    }
​
    public static void main(String[] args) throws Exception {
        doThreadSafeCheck();
    }
}
​