Java复制数组的方法

Java复制数组的⽅法
java数组拷贝主要有四种⽅法，分别是循环赋值，System.arraycopy(),Arrays.copyOf()(或者Arrays.copyOfRange)和clone()⽅法。

下⾯分别介绍⼀下这⼏种拷贝。

⼀、循环拷贝（速度相对⽐较慢）
循环拷贝其实没什么好说的啦，就是⽤⼀个for循环进⾏元素的逐个拷贝，进⾏深拷贝或者浅复制这个⼤家可以⾃⼰把握。

⼆、System.arraycopy（浅拷贝）
这个是系统提供的拷贝⽅式，也是我们推荐使⽤的拷贝⽅式，它是浅拷贝，也就是说对于⾮基本类型⽽⾔，它拷贝的是对象的引⽤，⽽不是去新建⼀个新的对象。

通过它的代码我们可以看到，这个⽅法不是⽤java语⾔写的，⽽是底层⽤c或者c++实现的，因⽽速度会⽐较快。

1public static native void arraycopy
2 (Object src, int srcPos,Object dest, int destPos,int length);
通过源代码我们可以看到，关键字native说明它不是⽤java语⾔写的，⽽是调⽤其他语⾔的代码。

1、先来看看基本数据类型的System.arraycopy() ⽅法拷贝：
1import java.util.Arrays;
2public class TestDemo {
3public static void main(String[] args) {
4
5int[] array1 = new int[]{1,2,8,7,6};
6int[] array2 = new int[array1.length];
7 System.arraycopy(array1, 0, array2, 0, array1.length);
8
9 System.out.println("array1 = " + Arrays.toString(array1));
10 System.out.println("array2 = " + Arrays.toString(array2));
11 System.out.println("=========================");
12
13 array2[0] = 100;
14 System.out.println("array1 = " + Arrays.toString(array1));
15 System.out.println("array2 = " + Arrays.toString(array2));
16
17 }
18 }
这段程序的结果是：
array1 = [1, 2, 8, 7, 6]
array2 = [1, 2, 8, 7, 6]
=========================
array1 = [1, 2, 8, 7, 6]
array2 = [100, 2, 8, 7, 6]
由结果可以看出，当对复制数组的某个元素进⾏改变时，并不影响被复制数组对应元素，即对于基本数据类型来说System.arraycopy()⽅法是深拷贝。

2、同样的，看⼀下当对象不是基本数据类型，⽽是引⽤数据类型时的情况
看以下例⼦：
1class TestArray{
2private int val = 10;
3public void setVal(int val){
4this.val = val;
5 }
6public int getVal(){
7return this.val;
8 }
9 }
10
11public class TestDemo {
12/**数组输出⽅法 */
13public static void printArray(TestArray[] array){
14for(int i = 0;i < array.length;i++){
15 System.out.print(array[i].getVal()+" ");
16 }
17 System.out.println();
18 }
19
20public static void main(String[] args) {
21 TestArray[] array1 = new TestArray[3];
22// 数组引⽤赋值
23for (int i = 0; i < array1.length; i++){
24 array1[i] = new TestArray();
25 }
26
27 TestArray[] array2 = new TestArray[array1.length];
28// 数组System.arraycopy()⽅法复制
29 System.arraycopy(array1,0,array2,0,array1.length);
30
31 printArray(array1);
32 printArray(array2);
33 System.out.println("==========");
34
35 array2[0].setVal(100);;
36 printArray(array1);
37 printArray(array2);
38 }
39 }
这段程序的结果是：
10 10 10
10 10 10
==========
100 10 10
100 10 10
由结果可以看出，当对复制数组的某个元素进⾏改变时，被复制数组对应元素也随之改变，即对于引⽤数据类型来说
System.arraycopy() ⽅法是浅拷贝。

三、Arrays.copyOf（浅拷贝）
这个⽅法也是浅拷贝，为什么呢？我们看⼀下它的源代码就知道了。

1public static byte[] copyOfRange(byte[] original, int from, int to) {
2int newLength = to - from;
3if (newLength < 0)
4throw new IllegalArgumentException(from + " > " + to);
5byte[] copy = new byte[newLength];
6 System.arraycopy(original, from, copy, 0,Math.min(original.length - from, newLength));
7return copy;
8 }
可以看到其实Arrays.copyOf()⽅法在底层是调⽤了 System.arraycopy() ⽅法来实现复制，即可以把Arrays.copyOf() ⽅法看作是System.arraycopy() ⽅法的衍⽣⽅法，故它的执⾏机理与 System.arraycopy() ⽅法相同。

所以 Arrays.copyOf() ⽅法对于基本数据类型来说是深拷贝，对引⽤类型来说是浅拷贝。

四、对象拷贝（Object.clone）
clone()⽐较特殊，对于对象⽽⾔，它是深拷贝，但是对于数组⽽⾔，它是浅拷贝。

⾸先讲⼀下对象的拷贝，它是深拷贝，⼤家可以⽤对象去测试⼀下。

下⾯我们看⼀下它的源代码：
1protected native Object clone() throws CloneNotSupportedException;
这⾥也有native关键字，所以也是底层的c语⾔实现的。

还要注意的是，这⾥修饰符是protected，也就是说，我们创建了⼀个Object类以后，是不能直接调⽤这个clone（）⽅法的，因为protected关键字只允许同⼀个包内的类和它的⼦类调⽤，所以我们声明⼀个object类时，肯定不是同⼀个包内，所以就不能去调⽤它。

要调⽤这个⽅法，就需要我们写⼀个类，然后声明实现cloneable接⼝就好了，不需要去显⽰地声明继承于object，因为java中的类如果不显⽰说明⽗类的话，默认⽗类就是object。

然后我们继承这个⽅法：
1 @Override
2public Object clone() throws CloneNotSupportedException {
3// TODO Auto-generated method stub
4return super.clone();
5 }
这⾥需要是，为了能够在不同包内去调⽤这个⽅法，我们需要把这个权限升级为public。

现在我们就可以调⽤这个类的clone()⽅法去拷贝我们的类了。

五、数组拷贝
对于数组⽽⾔，它不是简单的将引⽤赋值为另外⼀个数组引⽤，⽽是创建⼀个新的数组。

但是我们知道，对于数组本⾝⽽⾔，它它的元素是对象的时候，本来数组每个元素中保存的就是对象的引⽤，所以，拷贝过来的数组⾃然⽽⾔也是对象的引⽤，所以对于数组对象元素⽽
⾔，它⼜是浅拷贝。

我们⽤以下代码验证⼀下：
1class Aby implements Cloneable{
2public int i;
3public Aby(int i) {
4this.i = i;
5 }
6 @Override
7public Object clone() throws CloneNotSupportedException {
8// TODO Auto-generated method stub
9return super.clone();
10 }
11 }
12public class Solution {
13
14public static void main(String[] args) throws CloneNotSupportedException {
15 Aby aby1 = new Aby(1);
16 Aby aby2 = (Aby) aby1.clone();
17 aby1.i = 2;
18 System.out.println(aby1.i); //2
19 System.out.println(aby2.i); //1
20
21 Aby[] arr = {aby1,aby2};
22
23 Aby[] arr2 = arr.clone();
24 arr2[0].i = 3;
25 System.out.println(arr[0].i); //3
26 System.out.println(arr2[0].i); //3
27 }
28 }。