java 基础——一维数组的拷贝
文章目录
- 深拷贝
- 浅拷贝
- 数组五种拷贝方式
- for循环拷贝
- 基本类型
- 引用类型
- 总结
- clone拷贝方式
- 基本类型
- 引用类型
- 总结
- Sysout.arraycopy（）
- 基本类型
- 引用类型
- 总结
- Arrays.copyOf(T[] original, int newLength)
- 基本类型
- 引用类型
- 总结
深拷贝
深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。
浅拷贝
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。
数组五种拷贝方式
for循环拷贝
基本类型
public static void main(String[] args) {
int[] array1 = {1,5,6,2,3,8};
int[] array2 = new int[array1.length];
System.out.println("数组1 ："+Arrays.toString(array1));
for(int i = 0;i < array1.length;i++){
array2[i] = array1[i];
}
System.out.println("数组2 "+Arrays.toString(array2));
System.out.println("===改变后===");
array2[0] = 1000;
System.out.println("数组1 "+Arrays.toString(array1));
System.out.println("数组2 "+Arrays.toString(array2));
}
运行结果：
数组1 ：[1, 5, 6, 2, 3, 8]
数组2 [1, 5, 6, 2, 3, 8]
=改变后=
数组1 [1, 5, 6, 2, 3, 8]
数组2 [1000, 5, 6, 2, 3, 8]
引用类型
public static void main(String[] args) {
test[] array1 = {new test(),new test(),new test()};
test[] array2 = new test[array1.length];
System.out.print("数组1：");
show(array1);
for(int i = 0;i < array1.length;i++){
array2[i] = array1[i];
}
array2[0].setVal(30);
System.out.print("数组2：");
show(array2);
System.out.println("===修改后===");
System.out.print("数组1：");
show(array1);
System.out.print("数组2：");
show(array2);
}
运行结果：
数组1：[10,10,10,}
数组2：[30,10,10,}
=修改后=
数组1：[30,10,10,}
数组2：[30,10,10,}
总结
从上面的例子我们可以看出：for 循环啊拷贝基本类型数组的时候，改变其中一个并没有改变另外一个，所以拷贝基本类型是深拷贝。for 循环拷贝引用类型数组的时候，改变其中一个会影响另外一个，所以拷贝引用类型的是浅拷贝。
clone拷贝方式
基本类型
public static void main(String[] args) {
int[] array1 = {10,10,10};
int[] array2 = new int[array1.length];
array2 = array1.clone();
System.out.println("数组1："+ Arrays.toString(array1));
System.out.println("数组2："+ Arrays.toString(array2));
array2[0] = 30;
System.out.println("===修改后===");
System.out.println("数组1："+ Arrays.toString(array1));
System.out.println("数组2："+ Arrays.toString(array2));
}
运行结果：
数组1：[10, 10, 10]
数组2：[10, 10, 10]
=修改后=
数组1：[10, 10, 10]
数组2：[30, 10, 10]
引用类型
public static void main(String[] args) {
test[] array1 = {new test(),new test(),new test()};
test[] array2 = new test[array1.length];
array2 = array1.clone();
System.out.print("数组1：");
show(array1);
System.out.print("数组2：");
show(array2);
array2[0].setVal(30);
System.out.println("===修改后===");
System.out.print("数组1：");
show(array1);
System.out.print("数组2：");
show(array2);
}
运行结果：
数组1：[10,10,10,}
数组2：[10,10,10,}
=修改后=
数组1：[30,10,10,}
数组2：[30,10,10,}
总结
clone 方式拷贝数组对于基本类型来说改变其中一个并没有改变另外一个，对于引用类型来说，改变其中一个也影响了另外一个。所以clone基本类型是深拷贝，对于引用类型来说是浅拷贝。
Sysout.arraycopy（）
相对较快的拷贝方法，native 方法。
基本类型
arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
src :源数组。
srcPos : 源数组的开始位置0， 开始拷贝位置
dest :拷贝到目标数组。
destPos :拷贝到目标数组的位置。
lenght : 源数组拷多大。
public static void main(String[] args) {
int[] array1 = {10,10,10};
int[] array2 = new int[array1.length];
System.arraycopy(array1,0,array2,0,array1.length);
System.out.println("数组1："+ Arrays.toString(array1));
System.out.println("数组2："+ Arrays.toString(array2));
array2[0] = 30;
System.out.println("===修改后===");
System.out.println("数组1："+ Arrays.toString(array1));
System.out.println("数组2："+ Arrays.toString(array2));
}
运行结果：
数组1：[10, 10, 10]
数组2：[10, 10, 10]
=修改后=
数组1：[10, 10, 10]
数组2：[30, 10, 10]
引用类型
public static void main(String[] args) {
test[] array1 = {new test(),new test(),new test()};
test[] array2 = new test[array1.length];
System.arraycopy(array1,0,array2,0,array1.length);
System.out.print("数组1：");
show(array1);
System.out.print("数组2：");
show(array2);
array2[0].setVal(30);
System.out.println("===修改后===");
System.out.print("数组1：");
show(array1);
System.out.print("数组2：");
show(array2);
}
运行结果：
数组1：[10,10,10,}
数组2：[10,10,10,}
=修改后=
数组1：[30,10,10,}
数组2：[30,10,10,}
总结
System.arraycopy() 方式拷贝数组对于基本类型来说改变其中一个并没有改变另外一个，对于引用类型来说，改变其中一个也影响了另外一个。所以clone基本类型是深拷贝，对于引用类型来说是浅拷贝。
Arrays.copyOf(T[] original, int newLength)
T[] original：原始数组。
int newLength：新的数组长度。
基本类型
public static void main(String[] args) {
int[] array1 = {10,10,10};
int[] array2 = new int[array1.length];
array2 = Arrays.copyOf(array1,array1.length);
System.out.println("数组1："+ Arrays.toString(array1));
System.out.println("数组2："+ Arrays.toString(array2));
array2[0] = 30;
System.out.println("===修改后===");
System.out.println("数组1："+ Arrays.toString(array1));
System.out.println("数组2："+ Arrays.toString(array2));
}
运行结果：
数组1：[10, 10, 10]
数组2：[10, 10, 10]
=修改后=
数组1：[10, 10, 10]
数组2：[30, 10, 10]
引用类型
public static void main(String[] args) {
test[] array1 = {new test(),new test(),new test()};
test[] array2 = new test[array1.length];
array2 = Arrays.copyOf(array1,array1.length);
System.out.print("数组1：");
show(array1);
System.out.print("数组2：");
show(array2);
array2[0].setVal(30);
System.out.println("===修改后===");
System.out.print("数组1：");
show(array1);
System.out.print("数组2：");
show(array2);
}
运行结果：
数组1：[10,10,10,}
数组2：[10,10,10,}
=修改后=
数组1：[30,10,10,}
数组2：[30,10,10,}
总结
Arrays.copyOf() 方式拷贝数组对于基本类型来说改变其中一个并没有改变另外一个，对于引用类型来说，改变其中一个也影响了另外一个。所以Arrays.copyOf() 基本类型是深拷贝，对于引用类型来说是浅拷贝。