数组拷贝System.arraycop()和Arrays.copyOf()

System.arraycop

System.arraycopy(src, srcPos, dest, destPos, length);

• src表示源数组
• srcPos表示源数组中拷贝元素的起始位置。
• dest表示目标数组
• destPos表示拷贝到目标数组的起始位置
• length表示拷贝元素的个数

System.arraycopy方法：如果是数组比较大，那么使用System.arraycopy会比较有优势，因为其使用的是内存复制，省去了大量的数组寻址访问等时间

复制指定源数组src到目标数组dest。复制从src的srcPos索引开始，复制的个数是length，复制到dest的索引从destPos开始。

需要注意的是在进行数组拷贝时，目标数组必须有足够的空间来存放拷贝的元素，否则就会发生角标越界异常。

通过一个案例来演示数组元素的拷贝。

// 1、测试复制到别的数组上
// 将ids数组的索引从0开始其后5个数，复制到ids2数组的索引从0开始
int[] ids = {1, 2, 3, 4, 5};
int[] ids2 = new int[5];
System.arraycopy(ids, 0, ids2, 0, 5);
System.out.println(Arrays.toString(ids2)); // [1, 2, 3, 4, 5]

---

类型转换问题

Object[] o1 = {1, 2, 3, 4.5, 6.7};
Integer[] o2 = new Integer[5];
try {
    System.arraycopy(o1, 0, o2, 0, o1.length);
} catch (ArrayStoreException ex) {
// 发生存储转换，部分成功的数据会被复制过去
    System.out.println("拷贝发生异常：数据转换错误，无法存储。");
}
// 从结果看，前面3个可以复制的数据已经被存储了。剩下的则没有
System.out.println(Arrays.toString(o2)); // [1, 2, 3, null, null]

二维数组复制后改变复制后的数组

如果是复制一个一维数组，那么改变复制后的数组并不影响原数组。但是如果复制一个二维数组，那么改变其中任何一个数组，那么另一个的值也发生了变化。

java其实没有二维数组的概念，平常实现的二维数组只是元素是一维数组的数组，而数组也是引用类型，继承自 Object类。数组是new出来的。这些性质也就导致arraycopy()二维数组时出现的问题。

如果是一维数组，那么元素都是基础类型（如int，double等），使用arraycopy()方法后，是把原数组的值传给了新数组，属于值传递。而如果是二维数组，数组的第一维装的是一个一维数组的引用，第二维里是元素数值。

对二维数组应用arraycopy()方法后，第一维的引用被复制给新数组的第一维，也就是两个数组的第一维都指向相同的“那些数组”。而这时改变其中任何一个数组的元素的值，其实都修改了“那些数组”的元素的值，所以原数组和新数组的元素值都一样了。

@Test
public void testCopy2(){
    int[] s1 = {1, 2, 3, 4, 5};
    int[] s2 = new int[5];
    System.arraycopy(s1, 0, s2, 0, 5);
 
    System.out.println("This is s1");
    for(int aS1 : s1) {
        System.out.print(aS1 + " , ");
    }
 
    s2[2] = 111;
    System.out.println("\nThis is s2");
    for(int aS2 : s2) {
        System.out.print(aS2 + " , ");
    }
    System.out.println("\nThis is s1");
    for(int aS1 : s1) {
        System.out.print(aS1 + " , ");
    }
 
    System.out.println("\n-----------------------");
    //二维数组
    int[][] s3 = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
    int[][] s4 = new int[s3.length][s3[0].length];
    System.out.println("This is s3");
    System.arraycopy(s3, 0, s4, 0, s3.length);
    for (int[] aS3 : s3) {
        for (int j = 0; j < s4[0].length; j++) {
            System.out.print(aS3[j] + ",");
        }
    }
 
    s4[1][3] = 111;
    System.out.println("\nThis is s4");
    for (int[] aS4 : s4) {
        for (int j = 0; j < s4[0].length; j++) {
            System.out.print(aS4[j] + ",");
        }
    }
    System.out.println("\nThis is s3");
    for (int[] aS3 : s3) {
        for (int j = 0; j < s4[0].length; j++) {
            System.out.print(aS3[j] + ",");
        }
    }
}

结果

This is s3 ： 1,2,3,4,5,6,7,8,9,10,

This is s4 ： 1,2,3,4,5,6,7,8,111,10,

This is s3 ： 1,2,3,4,5,6,7,8,111,10,

---

Arrays.copyOf()

Arrays.copyOf(dest,length);

• dest是要拷贝的数组
• length为拷贝长度

int[] desc = {1, 2, 3, 4, 5}; 
int[] arr = Arrays.copyOf(desc, 5);

结果：

1 2 3 4 5

Arrays.copyOf()方法返回的数组是新的数组对象，原数组对象仍是原数组对象，不变，该拷贝不会影响原来的数组。

该方法对于不同的数据类型都有相应的方法重载。

---

Arrays.copyOf() 方法源码如下：

/**
 * @Description 复制指定的数组, 如有必要用 null 截取或填充，以使副本具有指定的长度
 * 对于所有在原数组和副本中都有效的索引，这两个数组相同索引处将包含相同的值
 * 对于在副本中有效而在原数组无效的所有索引，副本将填充 null，当且仅当指定长度大于原数组的长度时，这些索引存在
 * 返回的数组属于 newType 类
 
 * @param original 要复制的数组
 * @param newLength 副本的长度
 * @param newType 副本的类
 * 
 * @return T 原数组的副本，截取或用 null 填充以获得指定的长度
 * @throws NegativeArraySizeException 如果 newLength 为负
 * @throws NullPointerException 如果 original 为 null
 * @throws ArrayStoreException 如果从 original 中复制的元素不属于存储在 newType 类数组中的运行时类型

 * @since 1.6
 */
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;
}

从代码可知，Arrays.copyOf()数组拷贝时调用的是本地方法 System.arraycopy()；

源代码发现copyOf()，在其内部创建了一个新的数组，然后调用arrayCopy()向其复制内容，返回出去

Arrays.copyOf()总结：

1. copyOf()的实现是用的是arrayCopy();

2. arrayCopy()需要目标数组，对两个数组的内容进行可能不完全的合并操作。

3. copyOf()在内部新建一个数组，调用arrayCopy()将original内容复制到copy中去，并且长度为newLength。返回copy;

4. arraycopy 方法会因为新数组大小比久数组大小小而报IndexOutOfBoundsException;

---

【题目练习】

• 将两个数组合并排序

---

【转载自文章】

• System.arraycopy方法和Arrays.copyOf()

• Arrays.copyOf()方法理解