【Java深入】深拷貝與淺拷貝詳解
阿新 • • 發佈：2019-02-18
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)。 這就叫做引用拷貝。
例1 圖解：
（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 圖解：
注：深拷貝和淺拷貝都是物件拷貝
2.淺拷貝
（1）定義：
被複制物件的所有變數都含有與原來的物件相同的值，而所有的對其他物件的引用仍然指向原來的物件。即物件的淺拷貝會對“主”物件進行拷貝，但不會複製主物件裡面的物件。”裡面的物件“會在原來的物件和它的副本之間共享。
簡而言之，淺拷貝僅僅複製所考慮的物件，而不復制它所引用的物件
（2）淺拷貝例項：
例3：
package blog;
/**
* Created by 白夜行 on 2017/5/8.
*/
public class ShallowCopy {
public static void 輸出結果：
拷貝後
Dream
18
Delacey
29
修改老師的資訊後-------------
Jam
Jam結果分析： 兩個引用student1和student2指向不同的兩個物件，但是兩個引用student1和student2中的兩個teacher引用指向的是同一個物件，所以說明是淺拷貝。
例3 圖解：
3.深拷貝
（1）定義：
深拷貝是一個整個獨立的物件拷貝，深拷貝會拷貝所有的屬性,並拷貝屬性指向的動態分配的記憶體。當物件和它所引用的物件一起拷貝時即發生深拷貝。深拷貝相比於淺拷貝速度較慢並且花銷較大。
簡而言之，深拷貝把要複製的物件所引用的物件都複製了一遍。
（2）實現深拷貝（例項1）：
例4：
package blog;
/**
* Created by 白夜行 on 2017/5/8.
*/
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更改後）：
（3）利用序列化實現深拷貝（例項2）
例5：
package blog;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* Created by 白夜行 on 2017/5/13.
*/
public class DeepCopyServiable {
public static void main(String[] args) throws Exception {
Teacher3 t = new Teacher3();
t.setName("Taylor");
t.setAge(28);
Student3 s1 = new Student3();
s1.setAge(20);
s1.setName("blank space");
s1.setTeacher(t);
Student3 s2 = (Student3) s1.deepClone();
System.out.println("拷貝後:");
System.out.println(s2.getName());
System.out.println(s2.getAge());
System.out.println(s2.getTeacher().getName());
System.out.println(s2.getTeacher().getAge());
System.out.println("---------------------------");
t.setName("swift");
System.out.println("修改後：");
System.out.println(s1.getTeacher().getName());
System.out.println(s2.getTeacher().getName());
}
}
class Teacher3 implements Serializable
{
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 Student3 implements Serializable
{
private String name;
private int age;
private Teacher3 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 Teacher3 getTeacher()
{
return teacher;
}
public void setTeacher(Teacher3 teacher)
{
this.teacher = teacher;
}
public Object deepClone() throws Exception
{
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
}
輸出結果：
拷貝後:
blank space
20
Taylor
28
---------------------------
修改後：
swift
Taylor結果分析：說明用序列化的方式實現了物件的深拷貝
本人才疏學淺，若有錯，請指出
謝謝！