深拷貝與淺拷貝詳解
在講解深拷貝與淺拷貝講解之前,需要先弄懂拷貝的分類:引用拷貝和對象拷貝。
註:深拷貝和淺拷貝都是對象拷貝
1.拷貝的引入
(1)引用拷貝
創建一個指向對象的引用變量的拷貝。
例1:
Teacher teacher = new Teacher("Taylor",26);
Teacher otherteacher = teacher;
System.out.println(teacher);
System.out.println(otherteacher);
輸出結果:
blog.Teacher@355da254
blog.Teacher@355da254
結果分析:由輸出結果可以看出,它們的地址值是相同的,那麽它們肯定是同一個對象。teacher和otherteacher的只是引用而已,他們都指向了一個相同的對象Teacher(“Taylor”,26)。 這就叫做引用拷貝。
(2)對象拷貝
創建對象本身的一個副本。
例2:
Teacher teacher = new Teacher("Swift",26);
Teacher otherteacher = (Teacher)teacher.clone();
System.out.println(teacher);
System.out.println(otherteacher);
輸出結果:
blog.Teacher@355da254
blog.Teacher@4dc63996
結果分析:由輸出結果可以看出,它們的地址是不同的,也就是說創建了新的對象, 而不是把原對象的地址賦給了一個新的引用變量,這就叫做對象拷貝。
2.淺拷貝
(1)定義:
被復制對象的所有變量都含有與原來的對象相同的值,而所有的對其他對象的引用仍然指向原來的對象。即對象的淺拷貝會對“主”對象進行拷貝,但不會復制主對象裏面的對象。”裏面的對象“會在原來的對象和它的副本之間共享。
簡而言之,淺拷貝僅僅復制所考慮的對象,而不復制它所引用的對象
(2)淺拷貝實例:
例3:
public class ShallowCopy {
public static void main(String[] args) throws CloneNotSupportedException {
Teacher teacher = new Teacher();
teacher.setName("Delacey");
teacher.setAge(29);
Student2 student1 = new Student2();
student1.setName("Dream");
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("Jam");
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;
}
@Override
public Object clone() throws CloneNotSupportedException
{
Object object = super.clone();
return object;
}
}
輸出結果:
拷貝後
Dream
18
Delacey
29
修改老師的信息後-------------
Jam
Jam
結果分析: 兩個引用student1和student2指向不同的兩個對象,但是兩個引用student1和student2中的兩個teacher引用指向的是同一個對象,所以說明是淺拷貝。
例3 圖解:
3.深拷貝
(1)定義:
深拷貝是一個整個獨立的對象拷貝,深拷貝會拷貝所有的屬性,並拷貝屬性指向的動態分配的內存。當對象和它所引用的對象一起拷貝時即發生深拷貝。深拷貝相比於淺拷貝速度較慢並且花銷較大。
簡而言之,深拷貝把要復制的對象所引用的對象都復制了一遍。
(2)實現深拷貝(實例1):
例4:
public class DeepCopy {
public static void main(String[] args) throws Exception
{
Teacher2 teacher = new Teacher2();
teacher.setName("Delacey");
teacher.setAge(29);
Student3 student1 = new Student3();
student1.setName("Dream");
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("Jam");
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;
}
@Override
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;
}
@Override
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;
}
}
輸出結果:
拷貝後
Dream
18
Delacey
29
修改老師的信息後-------------
Jam
Delacey
結果分析:
兩個引用student1和student2指向不同的兩個對象,兩個引用student1和student2中的兩個teacher引用指向的是兩個對象,但對teacher對象的修改只能影響student1對象,所以說是深拷貝。
例4 圖解1(teacher姓名Delacey更改前):
例4 圖解2(teacher姓名Jam更改後):
深拷貝與淺拷貝詳解