数组拷贝
首先了解深拷贝 浅拷贝
数组的四种拷贝方式：
1.for循环拷贝
代码示例：
import java.util.Arrays;
public class TestDemo{
public static void main(String[] args) {
int[] array1 ={1,2,3,4,5,6};
int[] array2 =new int [array1.length];
for (int i = 0; i <array1.length ; i++) {
array2[i] = array1[i];
}
System.out.println(Arrays.toString(array1));
System.out.println(Arrays.toString(array2));
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
结果：
此时，修改array2 0下标的值，发现对array1没影响；
import java.util.Arrays;
public class TestDemo{
public static void main(String[] args) {
int[] array1 ={1,2,3,4,5,6};
int[] array2 =new int [array1.length];
for (int i = 0; i <array1.length ; i++) {
array2[i] = array1[i];
}
System.out.println("==============");
array2[0]=99;
System.out.println(Arrays.toString(array1));
System.out.println(Arrays.toString(array2));
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
结果：
创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中. 因此, 修改原数组, 不会影响到新数组，即通过一个引用去修改拷贝后的值，发现并不影响原来对象的值，这种拷贝属于深拷贝。
2.copyof拷贝
代码示例：
public static void main(String[] args) {
int[] array1 = {1,2,3,4,5,6};
System.out.println(Arrays.toString(array1));
int[] array2 = Arrays.copyOf(array1,array1.length);
System.out.println("==============");
array2[0]=99;
System.out.println(Arrays.toString(array1));
System.out.println(Arrays.toString(array2));
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
结果：
同第一个： copyOf 是将数组进行了 深拷贝, 即又创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中。因此, 修改原数组,不会影响到新数组。
3.System.arraycopy拷贝
import java.util.Arrays;
public class TestDemo {
public static void main(String[] args) {
int[] array1 = {1, 2, 3, 4, 5, 6};
int[] array2 = new int[array1.length];
System.out.println(Arrays.toString(array1));
System.arraycopy(array1, 0, array2, 0, array1.length);
System.out.println("==============");
array2[0] = 99;
System.out.println(Arrays.toString(array1));
System.out.println(Arrays.toString(array2));
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
结果：
System.arraycopy拷贝也为深拷贝。
前三种拷贝方式速度最快是System.arraycopy拷贝。
4.clone拷贝
引用.clone
克隆 这个引用所指向的对象
这个引用所指向的对象就会被克隆(生成一个副本)
- 1
- 2
- 3
代码示例;
public static void main(String[] args) {
int[] array1 = {1, 8, 9, 4, 13, 26};
System.out.println(Arrays.toString(array1));
//array2 指向了刚刚生成的副本
int [] array2 = array1.clone();
System.out.println("==============");
array2[0] = 99;
System.out.println(Arrays.toString(array1));
System.out.println(Arrays.toString(array2));
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
结果：
此时也可以看出，修改原数组, 不会影响到新数组。所以也为深拷贝。
实际上，本质来说这四种都属于浅拷贝
上面四种属于深拷贝的原因是因为刚刚数组中存放的是简单类型。
如果放的是引用类型，它们均属于浅拷贝。
画图说明浅拷贝：
当数组中存放的是引用类型时，修改array2中的某个元素的值，同时也修改了array1中的值，这种方法叫浅拷贝。
怎么修改成深拷贝呢？当我们拷贝array1时，将它所引用的值也拷贝过来，此时修改array2中的某个元素的值，array1中的值不变，如图：
总结：
这四种数组拷贝的方式均为浅拷贝
几个小知识点：
1.拷贝部分数组;
代码示例：
public static void main(String[] args) {
int[] array1 = {2, 8, 9, 10, 12, 26};
int[] ret = Arrays.copyOfRange(array1,2,5);
System.out.println(Arrays.toString(ret));
}
- 1
- 2
- 3
- 4
- 5
结果：
2.比较两个数组
代码示例：
public static void main(String[] args) {
int[] array1 = {2, 8, 9, 10, 12, 26};
int[] array2 = {2, 8, 9, 10, 12, 26, 30,35};
System.out.println(Arrays.equals(array1, array2));
}
- 1
- 2
- 3
- 4
- 5
结果：
3.数组完全填充
代码示例：
public static void main(String[] args) {
int[] array1 =new int[10];
Arrays.fill(array1,6);
System.out.println(Arrays.toString(array1));
}
- 1
- 2
- 3
- 4
- 5
结果：
4.数组部分填充
代码示例：
public static void main(String[] args) {
int[] array1 =new int[10];
Arrays.fill(array1,2,6,8);
System.out.println(Arrays.toString(array1));
}
- 1
- 2
- 3
- 4
- 5
结果：
完。（要我的命）
原文章：https://blog.csdn.net/weixin_44436675/article/details/112012315