什么是深拷贝和浅拷贝
首先要明白深拷贝和浅拷贝都是针对一个已有对象的操作。在Java中,除了基本数据类型外,还存在类的实例对象这个引用数据类型。而一般使用=做赋值操作的时候,对于基本数据类型,实际上是拷贝他的值,但是对于对象而言,其实赋值的只是这个对象的引用,将原对象的引用传递过去,他们实际上还是指向的同一个对象。
如果在拷贝这个对象的时候,只针对基本数据类型进行了拷贝,而对引用数据类型只是进行了引用的传递,而没有真是的创建一个新的对象,则认为是浅拷贝。反之,在对引用数据类型进行深拷贝时,创建一个新的对象,并且复制其内的成员变量,则认为时深拷贝。
数据如何在内存中存储
JVM在程序运行的时候会将内存划分为四个区域
堆区,栈区,静态方法去,常量区
基本数据类型的局部变量
方法中的基本类型的局部变量,都是存储虚拟机的堆内存中的,数据本身的值就是存储在栈内存中。每次给一个新变量赋值的时候,JVM首先会检验内存中有无该数据,如果有,就直接将这个变量指向该数据,没有的话就开辟一个新的内存空间存放数据,然后将变量指向该数据。
int age = 50;
int weight = 50;
int height = 100;
看上面的代码段,三个变量都是某个方法中的局部变量,当执行int age = 50的时候,首先会定义变量,存入变量表中。然后去栈中找是否存在值为50的内容,并将age变量指向50.当执行int weight = 50时,会在栈中找到50,直接将weight指向50.当方法执行完毕以后,方法局部变量会被JVM的垃圾回收器回收。
基本数据类型的成员变量和引用类型变量
public class Student{
private String name;
private int age;
private int grade;
}
上面是一个Student类,如果我们重写toString方法,直接输出一个实例化对象的话,会得到这样的输出Student@1b6d3586,这个其实就是Student类的地址
所以,对于引用数据类型来说,引用数据类型只存储在一个堆内存中的地址,而成员变量和方法被存储在堆内存中。
拷贝的引入
引用拷贝
创建一个指向对象的引用变量的拷贝
Teacher teacher = new Teacher("Taylor",26);
Teacher otherTeacher = teacher;;
System.out.println(teacher);
System.out.println(otherTeacher);
输出结果
blog.Teacher@335da254
blog.Teacher@335da254
由结果可以看出,他们的地址说相同的,所以肯定时同一个对象。teacher和otherTeacher只是引用而已,他们都指向了一个相同的对象Teacher("Taylor",26),这种叫做引用拷贝。
对象拷贝
创建对象本身的一个副本
Teacher teacher = new Teacher("Taylor",26);
Teacher otherTeacher = (Teacher)teacher.clone();
System.out.println(teacher);
System.out.println(otherTeacher);
输出结果
blog.Teacher@335da254
blog.Teacher@4dc63996
由输出结果可以看出,他们的地址时不同的,也就是说创建了新的对象,而不是把原对象的地址付给了一个新的引用变量,这个叫做对象拷贝
注意:深拷贝和浅拷贝都是对象拷贝
浅拷贝
被复制对象的所以变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象,就是说,浅拷贝仅仅复制所考虑的对象,而不会复制他所引用的对象。
package com.test;
public class ShallowCopy {
public static void main(String[] args) throws CloneNotSupportedException {
Teacher teacher = new Teacher();
teacher.setName("riemann");
teacher.setAge(27);
Student2 student1 = new Student2();
student1.setName("edgar");
student1.setAge(18);
student1.setTeacher(teacher);
Student2 student2 = (Student2) student1.clone();
System.out.println("拷贝后");
System.out.println(student2.getName());
System.out.println(student2.getAge());
System.out.println(student2.getTeacher().getName());
System.out.println(student2.getTeacher().getAge());
System.out.println("修改老师的信息后-------------");
// 修改老师的信息
teacher.setName("Games");
System.out.println(student1.getTeacher().getName());
System.out.println(student2.getTeacher().getName());
}
}
class Teacher implements Cloneable {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Student2 implements Cloneable {
private String name;
private int age;
private Teacher teacher;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
public Object clone() throws CloneNotSupportedException {
Object object = super.clone();
return object;
}
}
这里的核心方法时Student类中的clone()方法
输出:
拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
Games
此时两个引用指向不同的两个对象,但是两个引用中的两个teacher引用指向的是同一个对象,所有说明是浅拷贝。
深拷贝
深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配内存。当对象和它所引用的对象一起拷贝时即发生深拷贝,相比于浅拷贝花销更大。也就是说,深拷贝把要复制的对象和引用的对象都要复制了一遍。
package com.test;
public class DeepCopy {
public static void main(String[] args) throws CloneNotSupportedException {
Teacher2 teacher = new Teacher2();
teacher.setName("riemann");
teacher.setAge(27);
Student3 student1 = new Student3();
student1.setName("edgar");
student1.setAge(18);
student1.setTeacher(teacher);
Student3 student2 = (Student3) student1.clone();
System.out.println("拷贝后");
System.out.println(student2.getName());
System.out.println(student2.getAge());
System.out.println(student2.getTeacher().getName());
System.out.println(student2.getTeacher().getAge());
System.out.println("修改老师的信息后-------------");
// 修改老师的信息
teacher.setName("Games");
System.out.println(student1.getTeacher().getName());
System.out.println(student2.getTeacher().getName());
}
}
class Teacher2 implements Cloneable {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student3 implements Cloneable {
private String name;
private int age;
private Teacher2 teacher;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Teacher2 getTeacher() {
return teacher;
}
public void setTeacher(Teacher2 teacher) {
this.teacher = teacher;
}
public Object clone() throws CloneNotSupportedException {
// 浅复制时:
// Object object = super.clone();
// return object;
// 改为深复制:
Student3 student = (Student3) super.clone();
// 本来是浅复制,现在将Teacher对象复制一份并重新set进来
student.setTeacher((Teacher2) student.getTeacher().clone());
return student;
}
}
输出:
拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
riemann
两个引用指向的是两个对象,两个teacher引用指向的也是两个对象,但对teacher对象的修改只能影响student1对象,所有是深拷贝
总结:
需要拷贝对象的时候,如果一个对象内部数据类型只有基本类型,那么就可以使用浅拷贝,如果一个对象内部还有引用数据类型,可以使用深拷贝。
文章部分摘自@AI乔治