Java Clone深拷貝與淺拷貝的兩種實現(xiàn)方法
1.首先，你要知道怎么實現(xiàn)克隆：實現(xiàn)Cloneable接口，在bean里面重寫clone()方法，權(quán)限為public。
2.其次，你要大概知道什么是地址傳遞，什么是值傳遞。
3.最后，你要知道你為什么使用這個clone方法。
先看第一條，簡單的克隆代碼的實現(xiàn)。這個也就是我們在沒了解清楚這個Java的clone的時候，會出現(xiàn)的問題。
看完代碼，我再說明這個時候的問題。
先看我要克隆的學(xué)生bean的代碼：
package com.lxk.model;
/**
* 學(xué)生類：有2個屬性：1，基本屬性-String-name；2，引用類型-Car-car。
* <p>
* Created by lxk on 2017/3/23
*/
public class Student implements Cloneable {
private String name;
private Car car;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", car=" + car +
'}';
}
@Override
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return student;
}
}
學(xué)生內(nèi)部引用了Car這個bean
package com.lxk.model;
import java.util.List;
public class Car implements Comparable<Car> {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public Car() {
}
public Car(String sign, int price) {
this.sign = sign;
this.price = price;
}
public Car(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
public Car(String sign, int price, List<Dog> myDog, List<String> boys) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
this.boys = boys;
}
public String getSign() {
return sign;
}
public void setSign(String sign) {
this.sign = sign;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public List<Dog> getMyDog() {
return myDog;
}
public void setMyDog(List<Dog> myDog) {
this.myDog = myDog;
}
public List<String> getBoys() {
return boys;
}
public void setBoys(List<String> boys) {
this.boys = boys;
}
@Override
public int compareTo(Car o) {
//同理也可以根據(jù)sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
}
最后就是main測試類
package com.lxk.findBugs;
import com.lxk.model.Car;
import com.lxk.model.Student;
/**
* 引用傳遞也就是地址傳遞需要注意的地方，引起的bug
* <p>
* Created by lxk on 2017/3/23
*/
public class Bug2 {
public static void main(String[] args) {
Student student1 = new Student();
Car car = new Car("oooo", 100);
student1.setCar(car);
student1.setName("lxk");
//克隆完之后，student1和student2應(yīng)該沒關(guān)系的，修改student1不影響student2的值，但是完之后發(fā)現(xiàn)，你修改car的值，student2也受影響啦。
Student student2 = student1.clone();
System.out.println("學(xué)生2：" + student2);//先輸出student2剛剛克隆完之后的值，然后在修改student1的相關(guān)引用類型的屬性值(car)和基本屬性值(name)
car.setSign("X5");
student1.setName("xxx");
System.out.println("學(xué)生2：" + student2);//再次輸出看修改的結(jié)果
}
}
之后就該是執(zhí)行的結(jié)果圖了：
對上面執(zhí)行結(jié)果的疑惑，以及解釋說明：
我們可能覺得自己在bean里面實現(xiàn)clone接口，重寫了這個clone方法，那么學(xué)生2是經(jīng)由學(xué)生1clone，復(fù)制出來的，
那么學(xué)生1和學(xué)生2，應(yīng)該是毫不相干的，各自是各自，然后，在修改學(xué)生1的時候，學(xué)生2是不會受影響的。
但是結(jié)果，不盡人意。從上圖執(zhí)行結(jié)果可以看出來，除了名字，這個屬性是沒有被學(xué)生1影響，關(guān)于car的sign屬性已經(jīng)因為學(xué)生1的變化而變化，這不是我希望的結(jié)果。
可見，這個簡單的克隆實現(xiàn)也僅僅是個“淺克隆”，也就是基本類型數(shù)據(jù)，他是會給你重新復(fù)制一份新的，但是引用類型的，他就不會重新復(fù)制份新的。引用類型包括，上面的其他bean的引用，list集合，等一些引用類型。
那么怎么實現(xiàn)深克隆呢？
對上述代碼稍作修改，如下：
學(xué)生bean的clone重寫方法如下所示：
@Override
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
if (car != null) {
student.setCar(car.clone());
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return student;
}
然后還要Car類實現(xiàn)cloneable接口，復(fù)寫clone方法：
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
主測試代碼不動，這個時候的執(zhí)行結(jié)果如下：
可以看到，這個時候，你再修改學(xué)生1的值，就不會影響到學(xué)生2的值，這才是真正的克隆，也就是所謂的深克隆。
怎么舉一反三？
可以看到，這個例子里面的引用類型就一個Car類型的屬性，但是實際開發(fā)中，除了這個引用其他bean類型的屬性外，可能還要list類型的屬性值用的最多。
那么要怎么深克隆呢，就像我在Car bean類里面做的那樣，把所有的引用類型的屬性，都在clone一遍。那么你在最上層調(diào)用這個clone方法的時候，他就是真的深克隆啦。
我代碼里面那么判斷是為了避免空指針異常。當(dāng)然，這個你也得注意咯。
注意 重寫clone方法的時候，里面各個屬性的null的判斷哦。
上面的是override clone()方法來實現(xiàn)深克隆的。如果你這個要克隆的對象很復(fù)雜的話，你就不得不去每個引用到的對象去復(fù)寫這個clone方法，這個太啰嗦來，改的地方，太多啦。
還有個方法就是使用序列化來實現(xiàn)這個深拷貝
/**
* 對象的深度克隆，此處的對象涉及Collection接口和Map接口下對象的深度克隆
* 利用序列化和反序列化的方式進(jìn)行深度克隆對象
*
* @param object 待克隆的對象
* @param <T> 待克隆對象的數(shù)據(jù)類型
* @return 已經(jīng)深度克隆過的對象
*/
public static <T extends Serializable> T deepCloneObject(T object) {
T deepClone = null;
ByteArrayOutputStream baos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bais = null;
ObjectInputStream ois = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
bais = new ByteArrayInputStream(baos
.toByteArray());
ois = new ObjectInputStream(bais);
deepClone = (T)ois.readObject();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if(baos != null) {
baos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(oos != null) {
oos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try{
if(bais != null) {
bais.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try{
if(ois != null) {
ois.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return deepClone;
}
具體的使用如下：
/**
* 使用序列化來實現(xiàn)深拷貝簡單。但是，所涉及到的所有對象都的實現(xiàn)序列化接口。
*/
private static void cloneBySerializable() {
Student student1 = new Student();
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
student1.setCar(car);
student1.setName("lxk");
Student student2 = deepCloneObject(student1);
System.out.println("學(xué)生2：" + student2);
car.setSign("X5");
car.setMyDog(null);
student1.setName("xxx");
System.out.println("學(xué)生2：" + student2);
}
實現(xiàn)的效果，還是和上面的一樣的，但是這個就簡單多來，只需要給涉及到的每個引用類型，都去實現(xiàn)序列化接口就好啦。
總結(jié)
以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，謝謝大家對腳本之家的支持。如果你想了解更多相關(guān)內(nèi)容請查看下面相關(guān)鏈接
相關(guān)文章
本文主要介紹了java中&與&&的區(qū)別，具有很好的參考價值。下面跟著小編一起來看下吧2017-03-03
Java創(chuàng)建多線程異步執(zhí)行實現(xiàn)代碼解析
這篇文章主要介紹了Java創(chuàng)建多線程異步執(zhí)行實現(xiàn)代碼解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-07-07
這篇文章主要介紹了openjdk與Oraclejdk的區(qū)別，幫助大家更好的了解JAVA，感興趣的朋友可以了解下2020-08-08
這篇文章介紹的是java中的枚舉類型，對于枚舉類型的相關(guān)知識，我們也介紹過不少方面的內(nèi)容。希望本文能夠給你帶來幫助，下面來一起看看，有需要的可以參考借鑒。2016-09-09
Java基于JDBC實現(xiàn)事務(wù)，銀行轉(zhuǎn)賬及貨物進(jìn)出庫功能示例
這篇文章主要介紹了Java基于JDBC實現(xiàn)事務(wù)，銀行轉(zhuǎn)賬及貨物進(jìn)出庫功能,較為詳細(xì)的分析了事務(wù)操作的原理、實現(xiàn)方法及java基于jdbc連接數(shù)據(jù)庫實現(xiàn)銀行事務(wù)操作的相關(guān)技巧,需要的朋友可以參考下2017-12-12
一文教你如何通過三級緩存解決Spring循環(huán)依賴
這篇文章主要介紹了如何通過三級緩存解決?Spring?循環(huán)依賴,本文給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考價值，需要的朋友可以參考下2023-07-07
這篇文章主要介紹了SpringBoot多線程@Async的使用體驗，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-12-12
在項目開發(fā)地過程中經(jīng)常會用到字典存儲某些可配置的值，但相應(yīng)的也會給開發(fā)帶來復(fù)雜度，比如數(shù)據(jù)庫存儲的值為字典值：0，1,2,3這種類型的值，但是前端頁面卻需要展示為 啟動、禁用、刪除 等中文狀態(tài)，下面我們來看兩種解決方案2022-06-06
本篇文章主要介紹了springboot 文件上傳大小配置的方法，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-10-10
Java 實戰(zhàn)項目之誠途旅游系統(tǒng)的實現(xiàn)流程
讀萬卷書不如行萬里路，只學(xué)書上的理論是遠(yuǎn)遠(yuǎn)不夠的，只有在實戰(zhàn)中才能獲得能力的提升，本篇文章手把手帶你用java+SpringBoot+Vue+maven+Mysql實現(xiàn)一個精美的物流管理系統(tǒng),大家可以在過程中查缺補(bǔ)漏，提升水平2021-11-11