java深克隆（深拷貝）和淺克隆（淺拷貝）
java深克隆和淺克隆
基本概念
淺複製(淺克隆)
被複制對象的全部變量都含有與原來的對象相同的值，而全部的對其餘對象的引用仍然指向原來的對象。換言之，淺複製僅僅複製所拷貝的對象，而不復制它所引用的對象。java
-
深複製(深克隆)程序員被複制對象的全部變量都含有與原來的對象相同的值，除去那些引用其餘對象的變量。那些引用其餘對象的變量將指向被複制過的新對象，而再也不是原有的那些被引用的對象。換言之，深複製把要複製的對象所引用的對象都複製了一遍。架構
實現java深複製和淺複製的最關鍵的就是要實現Cloneable接口中的clone()方法。ide
如何使用clone()方法
首先咱們來看一下Cloneable接口：學習
官方解釋：測試
1：實現此接口則可使用java.lang.Object 的clone()方法，不然會拋出CloneNotSupportedException 異常this
2：實現此接口的類應該使用公共方法覆蓋clone方法spa
3：此接口並不包含clone 方法，因此實現此接口並不能克隆對象，這只是一個前提，還需覆蓋上面所講的clone方法。3d
public interface Cloneable {
}
複製代碼
看看Object裏面的Clone()方法：code
- clone()方法返回的是Object類型，因此必須強制轉換獲得克隆後的類型
- clone()方法是一個native方法，而native的效率遠遠高於非native方法，
- 能夠發現clone方法被一個Protected修飾，因此能夠知道必須繼承Object類才能使用，而Object類是全部類的基類，也就是說全部的類均可以使用clone方法
protected native Object clone() throws CloneNotSupportedException;
複製代碼
小試牛刀：
public class Person {
public void testClone(){
super.clone(); // 報錯了
}
}
複製代碼
事實倒是clone()方法報錯了，那麼確定奇怪了，既然Object是一切類的基類，而且clone的方法是Protected的，那應該是能夠經過super.clone()方法去調用的，然而事實倒是會拋出CloneNotSupportedException異常, 官方解釋以下：
- 對象的類不支持Cloneable接口
- 覆蓋方法的子類也能夠拋出此異常表示沒法克隆實例。
因此咱們更改代碼以下：
public class Person implements Cloneable{
public void testClone(){
try {
super.clone();
System.out.println("克隆成功");
} catch (CloneNotSupportedException e) {
System.out.println("克隆失敗");
e.printStackTrace();
}
}
public static void main(String[] args) {
Person p = new Person();
p.testClone();
}
}
複製代碼
要注意，必須將克隆方法寫在try-catch塊中，由於clone方法會把異常拋出，固然程序也要求咱們try-catch。
java.lang.object規範中對clone方法的約定
對任何的對象x，都有x.clone() !=x 由於克隆對象與原對象不是同一個對象對任何的對象x，都有x.clone().getClass()= =x.getClass()//克隆對象與原對象的類型同樣若是對象x的equals()方法定義恰當，那麼x.clone().equals(x)應該成立
對於以上三點要注意，這3項約定並無強制執行，因此若是用戶不遵循此約定，那麼將會構造出不正確的克隆對象，因此根據effective java的建議：
謹慎的使用clone方法，或者儘可能避免使用。
淺複製實例
對象中所有是基本類型
public class Teacher implements Cloneable{
private String name;
private int age;
public Teacher(String name, int age){
this.name = name;
this.age = age;
}
// 覆蓋
@Override
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
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 class test {
Teacher origin = new Teacher("tony", 11);
System.out.println(origin.getName());
Teacher clone = (Teacher) origin.clone();
clone.setName("clone");
System.out.println(origin.getName());
System.out.println(clone.getName());
}
複製代碼
結果：
tony tony clone
從運行結果和圖上能夠知道，克隆後的值變量會開闢新的內存地址，克隆對象修改值不會影響原來對象。
對象中含有引用類型
public class Teacher implements Cloneable{
private String name;
private int age;
private Student student;
public Teacher(String name, int age, Student student){
this.name = name;
this.age = age;
this.student = student;
}
// 覆蓋
@Override
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
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 Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
}
// 學生類
public class Student {
private String name;
private int age;
public Student(String name, int age){
this.name = name;
this.age = 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 class test {
public static void main(String[] args) {
Student student = new Student("學生1" ,11);
Teacher origin = new Teacher("老師", 11, student);;
Teacher clone = (Teacher) origin.clone();
System.out.println("比較克隆後的引用對象");
System.out.println(origin.getStudent().getClass() == clone.getStudent().getClass());
Student student2 = new Student("學生2", 12);
clone.setStudent(student2);
System.out.println("克隆後，比較克隆對象改變引用");
System.out.println(origin.getStudent().getClass() == clone.getStudent().getClass());
}
}
複製代碼
運行結果：
比較克隆後的引用對象 true 克隆後，比較克隆對象改變引用 true
如圖可知，引用類型只會存在一分內存地址，執行object的clone方法拷貝的也是引用的複製（這部分的內存空間不同，）可是引用指向的內存空間是同樣的，原對象修改引用變量或者淺拷貝對象修改引用變量都會引發雙方的變化
重點：綜上兩個方面能夠知道，Object的clone方法是屬於淺拷貝，基本變量類型會複製相同值，而引用變量類型也是會複製相同的引用。
深複製實例
從上面的淺拷貝能夠知道，對於引用的變量只會拷貝引用指向的地址，也就是指向同一個內存地址，可是不少狀況下咱們須要的是下面圖的效果：
深拷貝實現的是對全部可變(沒有被final修飾的引用變量)引用類型的成員變量都開闢內存空間因此通常深拷貝對於淺拷貝來講是比較耗費時間和內存開銷的。
深拷貝的兩種方式：
重寫clone方法實現深拷貝
學生類：
public class Student implements Cloneable {
private String name;
private int age;
public Student(String name, int age){
this.name = name;
this.age = age;
}
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
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 class Teacher implements Cloneable{
private String name;
private int age;
private Student student;
public Teacher(String name, int age, Student student){
this.name = name;
this.age = age;
this.student = student;
}
// 覆蓋
@Override
public Object clone() {
Teacher t = null;
try {
t = (Teacher) super.clone();
t.student = (Student)student.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return t;
}
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 Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
}
複製代碼
測試端：
public class test {
public static void main(String[] args) {
Student s = new Student("學生1", 11);
Teacher origin = new Teacher("老師原對象", 23, s);
System.out.println("克隆前的學生姓名：" + origin.getStudent().getName());
Teacher clone = (Teacher) origin.clone();
// 更改克隆後的學生信息 更改了姓名
clone.getStudent().setName("我是克隆對象更改後的學生2");
System.out.println("克隆後的學生姓名：" + clone.getStudent().getName());
}
}
複製代碼
運行結果：
克隆前的學生姓名：學生1 克隆後的學生姓名：我是克隆對象更改後的學生2
序列化實現深克隆
咱們發現上面經過object的clone方法去實現深克隆十分麻煩， 所以引出了另一種方式：序列化實現深克隆。
概念：
- 序列化：把對象寫到流裏
- 反序列化：把對象從流中讀出來
在Java語言裏深複製一個對象，經常能夠先使對象實現Serializable接口，而後把對象（實際上只是對象的一個拷貝）寫到一個流裏，再從流裏讀出來，即可以重建對象。
注意：
寫在流裏的是對象的一個拷貝，而原對象仍然存在於JVM裏面。對象以及對象內部全部引用到的對象都是可序列化的若是不想序列化，則須要使用transient來修飾
案例：
Teacher:
public class Teacher implements Serializable{
private String name;
private int age;
private Student student;
public Teacher(String name, int age, Student student){
this.name = name;
this.age = age;
this.student = student;
}
// 深克隆
public Object deepClone() throws IOException, ClassNotFoundException {
// 序列化
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();
}
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 Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
複製代碼
Student:
public class Student implements Serializable {
private String name;
private int age;
public Student(String name, int age){
this.name = name;
this.age = 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;
}
}
複製代碼
client：
public class test {
public static void main(String[] args) {
try {
Student s = new Student("學生1", 11);
Teacher origin = new Teacher("老師原對象", 23, s);
System.out.println("克隆前的學生姓名：" + origin.getStudent().getName());
Teacher clone = (Teacher) origin.deepClone();
// 更改克隆後的d學生信息 更改了姓名
clone.getStudent().setName("我是克隆對象更改後的學生2");
System.out.println("克隆後的學生姓名：" + clone.getStudent().getName());
}catch (Exception e){
e.printStackTrace();
}
}
}
複製代碼
固然這些工做都有現成的輪子了，藉助於Apache Commons能夠直接實現：
- 淺克隆：BeanUtils.cloneBean(Object obj);
- 深克隆：SerializationUtils.clone(T object);
最後探討
-
在java中爲何實現了Cloneable接口，就能夠調用Object中的Clone方法
參考如下回答：
號外號外：
- 若是有小夥伴以爲我寫的不錯的話能夠關注一下個人博客哦
- 能夠關注下方個人公衆號**
java架構師小密圈,回覆1**：獲取2Tjava架構師必備乾貨 ，另外：小夥伴能夠回覆任意想學的技術，能夠免費幫你搜尋，其實咱們還須要學不少！！！！！！
- 還會分享一些賺錢理財的小套路哦，歡迎你們來支持，一塊兒學習成長，程序員不只僅是搬瓦工！
公衆號：分享系列好文章
交流羣：一塊兒奔着java架構師努力
相關文章
- 1. 深淺拷貝，深淺克隆clone
- 2. 淺談BeanUtils的拷貝，深度克隆
- 3. java克隆之深拷貝與淺拷貝
- 4. Java拾遺：008 - 對象克隆與淺拷貝、深拷貝
- 5. Java 深克隆&淺克隆
- 6. 深克隆和淺克隆
- 7. 淺克隆和深克隆
- 8. java淺拷貝和深拷貝淺析
- 9. 淺談java淺拷貝和深拷貝
- 10. java 淺拷貝 深拷貝
- 更多相關文章...
- • XML DOM 克隆節點 - XML DOM 教程
- • TCP滑動窗口機制深度剖析 - TCP/IP教程
- • 算法總結-深度優先算法
- • Java 8 Stream 教程
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 深淺拷貝，深淺克隆clone
- 2. 淺談BeanUtils的拷貝，深度克隆
- 3. java克隆之深拷貝與淺拷貝
- 4. Java拾遺：008 - 對象克隆與淺拷貝、深拷貝
- 5. Java 深克隆&淺克隆
- 6. 深克隆和淺克隆
- 7. 淺克隆和深克隆
- 8. java淺拷貝和深拷貝淺析
- 9. 淺談java淺拷貝和深拷貝
- 10. java 淺拷貝 深拷貝