Java数组拷贝的四种⽅法：循环赋值、System.arraycopy（）、Arrays.。。。Java数组拷贝的四种⽅法
效率：System.arraycopy > clone > pyOf > 循环赋值
Java数组拷贝的四种⽅法：
循环赋值：速度相对较慢
System.arraycopy()：浅拷贝
Object.clone()
循环赋值
循环拷贝其实没什么好说的啦，就是⽤⼀个for循环进⾏元素的逐个拷贝，进⾏深拷贝或者浅复制这个⼤家可以⾃⼰把握。System.arraycopy()
这个是系统提供的拷贝⽅式，也是我们推荐使⽤的拷贝⽅式，它是浅拷贝，也就是说对于⾮基本类型⽽⾔，它拷贝的是对象的引⽤，⽽不是去新建⼀个新的对象。通过它的代码我们可以看到，这个⽅法不是
⽤java语⾔写的，⽽是底层⽤c或者c++实现的，因⽽速度会⽐较快。
public static native void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
通过源代码我们可以看到，关键字native说明它不是⽤java语⾔写的，⽽是调⽤其他语⾔的代码。
src：源数组
srcPos：源数组中的起始位置
dest：⽬标数组
destPos：⽬标数组中的起始位置
length：要复制数组元素的数量
import java.util.Arrays;
public class Solution {
工商部public static void main(String[] args)throws CloneNotSupportedException {
int[] src =new int[]{1,2,3,4,5};
int[] dest =new int[]{11,12,13,14,15,16};
int srcPos =2;
int destPos =3;
int length =2;
System.arraycopy(src, srcPos, dest, destPos, length);
System.out.String(dest));//[11, 12, 13, 3, 4, 16]用才造句
}
}
这个⽅法也是浅拷贝，为什么呢？我们看⼀下它的源代码就知道了。昆虫记知识点
public static byte[]copyOfRange(byte[] original,int from,int to){
int newLength = to - from;
if(newLength <0)
throw new IllegalArgumentException(from +" > "+ to);
贾宝玉的故事
byte[] copy =new byte[newLength];
最浪漫的事简谱
System.arraycopy(original, from, copy,0,
Math.min(original.length - from, newLength));
return copy;
}
实际上它调⽤的就是System.arraycopy，所以肯定也是浅拷贝。
Object.clone()
歌曲哭砂
clone()⽐较特殊，对于对象⽽⾔，它是深拷贝，但是对于数组⽽⾔，它是浅拷贝。
对象拷贝
⾸先讲⼀下对象的拷贝，它是深拷贝，⼤家可以⽤对象去测试⼀下。下⾯我们看⼀下它的源代码：
protected native Object clone()throws CloneNotSupportedException;
这⾥也有native关键字，所以也是底层的c语⾔实现的。
还要注意的是，这⾥修饰符是protected，也就是说，我们创建了⼀个Object类以后，是不能直接调⽤这个clone（）⽅法的，因为protected关键字只允许同⼀个包内的类和它的⼦类调⽤，所以我们声明⼀个object类时，肯定不是同⼀个包内，所以就不能去调⽤它。
要调⽤这个⽅法，就需要我们写⼀个类，然后声明实现cloneable接⼝就好了，不需要去显⽰地声明继承于object，因为java中的类如果不显⽰说明⽗类的话，默认⽗类就是object。然后我们继承这个⽅法：
@Override
public Object clone()throws CloneNotSupportedException {
空白名字// TODO Auto-generated method stub
return super.clone();
}
这⾥需要是，为了能够在不同包内去调⽤这个⽅法，我们需要把这个权限升级为public。现在我们就可以调⽤这个类的clone()⽅法去拷贝我们的类了。
见仁见智是什么意思public class Solution {
public static void main(String[] args)throws CloneNotSupportedException {
Cat cat1 =new Cat("abc",3);
System.out.println(cat1);//Cat@1b6d3586
Cat cat2 =(Cat) cat1.clone();
System.out.println(cat2);//Cat@4554617c
}
}
//被克隆的类要实现Cloneable接⼝
class Cat implements Cloneable {
private String name;
private int age;
public Cat(String name,int age){
this.name = name;
this.age = age;
}
@Override
protected Object clone()throws CloneNotSupportedException {
return super.clone();
}
}
数组拷贝
对于数组⽽⾔，它不是简单的将引⽤赋值为另外⼀个数组引⽤，⽽是创建⼀个新的数组。但是我们知道，对于数组本⾝⽽⾔，它它的元素是对象的时候，本来数组每个元素中保存的就是对象的引⽤，所以，拷贝过来的数组⾃然⽽⾔也是对象的引⽤，所以对于数组对象元素⽽⾔，它⼜是浅拷贝。我们⽤以下代码验证⼀下：
public class Solution {
public static void main(String[] args)throws CloneNotSupportedException {
Aby aby1 =new Aby(1);
Aby aby2 =(Aby) aby1.clone();
aby1.i =2;
System.out.println(aby1.i);//2
System.out.println(aby2.i);//1
Aby[] arr1 ={aby1, aby2};
Aby[] arr2 = arr1.clone();
arr2[0].i =3;
System.out.println(arr1[0].i);//3
System.out.println(arr2[0].i);//3
}
}
class Aby implements Cloneable {
public int i;
public Aby(int i){
this.i = i;
}
@Override
public Object clone()throws CloneNotSupportedException {
return super.clone();
}
}
复制引⽤和复制对象的区别
复制引⽤：是指将某个对象的地址复制，所以复制后的对象副本的地址和源对象相同，这样，当改变
副本的某个值后，源对象值也被改变；复制对象：是将源对象整个复制，对象副本和源对象的地址并不相同，当改变副本的某个值后，源对象值不会改变；
public class Solution {
public static void main(String[] args)throws CloneNotSupportedException {
Cat cat1 =new Cat("abc",3);//源对象
System.out.println("源对象地址："+ cat1);//源对象地址：Cat@1b6d3586 //调⽤clone⽅法，复制对象
Cat cat2 =(Cat) cat1.clone();
System.out.println("复制对象地址："+ cat2);//复制对象地址：Cat@4554617c //复制引⽤
Cat cat3 = cat1;
System.out.println("复制引⽤地址："+ cat3);//复制引⽤地址：Cat@1b6d3586 }
}
//被克隆的类要实现Cloneable接⼝
class Cat implements Cloneable {
private String name;
private int age;
public Cat(String name,int age){
this.name = name;
this.age = age;
}
@Override
protected Object clone()throws CloneNotSupportedException {
return super.clone();
}
}
