理解java中的深復(fù)制和淺復(fù)制
Java語言的一個優(yōu)點(diǎn)就是取消了指針的概念，但也導(dǎo)致了許多程序員在編程中常常忽略了對象與引用的區(qū)別，本文會試圖澄清這一概念。并且由于Java不能通過簡單的賦值來解決對象復(fù)制的問題，在開發(fā)過程中，也常常要要應(yīng)用clone（）方法來復(fù)制對象。本文會讓你了解什么是影子clone與深度clone，認(rèn)識它們的區(qū)別、優(yōu)點(diǎn)及缺點(diǎn)。
看到這個標(biāo)題，是不是有點(diǎn)困惑：Java語言明確說明取消了指針，因?yàn)橹羔樛窃趲矸奖愕耐瑫r也是導(dǎo)致代碼不安全的根源，同時也會使程序的變得非常復(fù)雜難以理解，濫用指針寫成的代碼不亞于使用早已臭名昭著的"GOTO"語句。Java放棄指針的概念絕對是極其明智的。但這只是在Java語言中沒有明確的指針定義，實(shí)質(zhì)上每一個new語句返回的都是一個指針的引用，只不過在大多時候Java中不用關(guān)心如何操作這個"指針"，更不用象在操作C＋＋的指針那樣膽戰(zhàn)心驚。唯一要多多關(guān)心的是在給函數(shù)傳遞對象的時候。
package com.zoer.src;
public class ObjRef {
Obj aObj = new Obj();
int aInt = 11;
public void changeObj(Obj inObj) {
inObj.str = "changed value";
}
public void changePri(int inInt) {
inInt = 22;
}
public static void main(String[] args) {
ObjRef oRef = new ObjRef();
System.out.println("Before call changeObj() method: " + oRef.aObj);
oRef.changeObj(oRef.aObj);
System.out.println("After call changeObj() method: " + oRef.aObj);
System.out.println("==================Print Primtive=================");
System.out.println("Before call changePri() method: " + oRef.aInt);
oRef.changePri(oRef.aInt);
System.out.println("After call changePri() method: " + oRef.aInt);
}
}
package com.zoer.src;
public class Obj {
String str = "init value";
public String toString() {
return str;
}
}
這段代碼的主要部分調(diào)用了兩個很相近的方法，changeObj()和changePri()。唯一不同的是它們一個把對象作為輸入?yún)?shù)，另一個把Java中的基本類型int作為輸入?yún)?shù)。并且在這兩個函數(shù)體內(nèi)部都對輸入的參數(shù)進(jìn)行了改動?？此埔粯拥姆椒ǎ绦蜉敵龅慕Y(jié)果卻不太一樣。changeObj()方法真正的把輸入的參數(shù)改變了，而changePri()方法對輸入的參數(shù)沒有任何的改變。
從這個例子知道Java對對象和基本的數(shù)據(jù)類型的處理是不一樣的。和C語言一樣，當(dāng)把Java的基本數(shù)據(jù)類型（如int，char，double等）作為入口參數(shù)傳給函數(shù)體的時候，傳入的參數(shù)在函數(shù)體內(nèi)部變成了局部變量，這個局部變量是輸入?yún)?shù)的一個拷貝，所有的函數(shù)體內(nèi)部的操作都是針對這個拷貝的操作，函數(shù)執(zhí)行結(jié)束后，這個局部變量也就完成了它的使命，它影響不到作為輸入?yún)?shù)的變量。這種方式的參數(shù)傳遞被稱為"值傳遞"。而在Java中用對象作為入口參數(shù)的傳遞則缺省為"引用傳遞"，也就是說僅僅傳遞了對象的一個"引用"，這個"引用"的概念同C語言中的指針引用是一樣的。當(dāng)函數(shù)體內(nèi)部對輸入變量改變時，實(shí)質(zhì)上就是在對這個對象的直接操作。
除了在函數(shù)傳值的時候是"引用傳遞"，在任何用"＝"向?qū)ο笞兞抠x值的時候都是"引用傳遞"。就是類似于給變量再起一個別名。兩個名字都指向內(nèi)存中的同一個對象。
在實(shí)際編程過程中，我們常常要遇到這種情況：有一個對象A，在某一時刻A中已經(jīng)包含了一些有效值，此時可能會需要一個和A完全相同新對象B，并且此后對B任何改動都不會影響到A中的值，也就是說，A與B是兩個獨(dú)立的對象，但B的初始值是由A對象確定的。在Java語言中，用簡單的賦值語句是不能滿足這種需求的。要滿足這種需求雖然有很多途徑，但實(shí)現(xiàn)clone（）方法是其中最簡單，也是最高效的手段。
Java的所有類都默認(rèn)繼承java.lang.Object類，在java.lang.Object類中有一個方法clone()。JDK API的說明文檔解釋這個方法將返回Object對象的一個拷貝。要說明的有兩點(diǎn)：一是拷貝對象返回的是一個新對象，而不是一個引用。二是拷貝對象與用new操作符返回的新對象的區(qū)別就是這個拷貝已經(jīng)包含了一些原來對象的信息，而不是對象的初始信息。
怎樣應(yīng)用clone()方法？
一個很典型的調(diào)用clone()代碼如下：
public class CloneClass implements Cloneable {
public int aInt;
public Object clone() {
CloneClass o = null;
try {
o = (CloneClass) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}
有三個值得注意的地方，一是希望能實(shí)現(xiàn)clone功能的CloneClass類實(shí)現(xiàn)了Cloneable接口，這個接口屬于java.lang包，java.lang包已經(jīng)被缺省的導(dǎo)入類中，所以不需要寫成java.lang.Cloneable。另一個值得請注意的是重載了clone()方法。最后在clone()方法中調(diào)用了super.clone()，這也意味著無論clone類的繼承結(jié)構(gòu)是什么樣的，super.clone()直接或間接調(diào)用了java.lang.Object類的clone()方法。下面再詳細(xì)的解釋一下這幾點(diǎn)。
應(yīng)該說第三點(diǎn)是最重要的，仔細(xì)觀察一下Object類的clone()一個native方法，native方法的效率一般來說都是遠(yuǎn)高于java中的非native方法。這也解釋了為什么要用Object中clone()方法而不是先new一個類，然后把原始對象中的信息賦到新對象中，雖然這也實(shí)現(xiàn)了clone功能。對于第二點(diǎn)，也要觀察Object類中的clone()還是一個protected屬性的方法。這也意味著如果要應(yīng)用clone()方法，必須繼承Object類，在Java中所有的類是缺省繼承Object類的，也就不用關(guān)心這點(diǎn)了。然后重載clone()方法。還有一點(diǎn)要考慮的是為了讓其它類能調(diào)用這個clone類的clone()方法，重載之后要把clone()方法的屬性設(shè)置為public。
那么clone類為什么還要實(shí)現(xiàn)Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其實(shí)這個接口僅僅是一個標(biāo)志，而且這個標(biāo)志也僅僅是針對Object類中clone()方法的，如果clone類沒有實(shí)現(xiàn)Cloneable接口，并調(diào)用了Object的clone()方法（也就是調(diào)用了super.Clone()方法），那么Object的clone()方法就會拋出CloneNotSupportedException異常。
以上是clone的最基本的步驟，想要完成一個成功的clone，還要了解什么是"影子clone"和"深度clone"。
什么是影子clone？
package com.zoer.src;
class UnCloneA {
private int i;
public UnCloneA(int ii) {
i = ii;
}
public void doublevalue() {
i *= 2;
}
public String toString() {
return Integer.toString(i);
}
}
class CloneB implements Cloneable {
public int aInt;
public UnCloneA unCA = new UnCloneA(111);
public Object clone() {
CloneB o = null;
try {
o = (CloneB) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}
public class ObjRef {
public static void main(String[] a) {
CloneB b1 = new CloneB();
b1.aInt = 11;
System.out.println("before clone,b1.aInt = " + b1.aInt);
System.out.println("before clone,b1.unCA = " + b1.unCA);
CloneB b2 = (CloneB) b1.clone();
b2.aInt = 22;
b2.unCA.doublevalue();
System.out.println("=================================");
System.out.println("after clone,b1.aInt = " + b1.aInt);
System.out.println("after clone,b1.unCA = " + b1.unCA);
System.out.println("=================================");
System.out.println("after clone,b2.aInt = " + b2.aInt);
System.out.println("after clone,b2.unCA = " + b2.unCA);
}
}
輸出結(jié)果：
before clone,b1.aInt = 11 before clone,b1.unCA = 111 ================================= after clone,b1.aInt = 11 after clone,b1.unCA = 222 ================================= after clone,b2.aInt = 22 after clone,b2.unCA = 222
輸出的結(jié)果說明int類型的變量aInt和UnCloneA的實(shí)例對象unCA的clone結(jié)果不一致，int類型是真正的被clone了，因?yàn)楦淖兞薭2中的aInt變量，對b1的aInt沒有產(chǎn)生影響，也就是說，b2.aInt與b1.aInt已經(jīng)占據(jù)了不同的內(nèi)存空間，b2.aInt是b1.aInt的一個真正拷貝。相反，對b2.unCA的改變同時改變了b1.unCA，很明顯，b2.unCA和b1.unCA是僅僅指向同一個對象的不同引用！從中可以看出，調(diào)用Object類中clone()方法產(chǎn)生的效果是：先在內(nèi)存中開辟一塊和原始對象一樣的空間，然后原樣拷貝原始對象中的內(nèi)容。對基本數(shù)據(jù)類型，這樣的操作是沒有問題的，但對非基本類型變量，我們知道它們保存的僅僅是對象的引用，這也導(dǎo)致clone后的非基本類型變量和原始對象中相應(yīng)的變量指向的是同一個對象。
大多時候，這種clone的結(jié)果往往不是我們所希望的結(jié)果，這種clone也被稱為"影子clone"。要想讓b2.unCA指向與b2.unCA不同的對象，而且b2.unCA中還要包含b1.unCA中的信息作為初始信息，就要實(shí)現(xiàn)深度clone。
怎么進(jìn)行深度clone？
把上面的例子改成深度clone很簡單，需要兩個改變：一是讓UnCloneA類也實(shí)現(xiàn)和CloneB類一樣的clone功能（實(shí)現(xiàn)Cloneable接口，重載clone()方法）。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();
package com.zoer.src;
class UnCloneA implements Cloneable {
private int i;
public UnCloneA(int ii) {
i = ii;
}
public void doublevalue() {
i *= 2;
}
public String toString() {
return Integer.toString(i);
}
public Object clone() {
UnCloneA o = null;
try {
o = (UnCloneA) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}
class CloneB implements Cloneable {
public int aInt;
public UnCloneA unCA = new UnCloneA(111);
public Object clone() {
CloneB o = null;
try {
o = (CloneB) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
o.unCA = (UnCloneA) unCA.clone();
return o;
}
}
public class CloneMain {
public static void main(String[] a) {
CloneB b1 = new CloneB();
b1.aInt = 11;
System.out.println("before clone,b1.aInt = " + b1.aInt);
System.out.println("before clone,b1.unCA = " + b1.unCA);
CloneB b2 = (CloneB) b1.clone();
b2.aInt = 22;
b2.unCA.doublevalue();
System.out.println("=================================");
System.out.println("after clone,b1.aInt = " + b1.aInt);
System.out.println("after clone,b1.unCA = " + b1.unCA);
System.out.println("=================================");
System.out.println("after clone,b2.aInt = " + b2.aInt);
System.out.println("after clone,b2.unCA = " + b2.unCA);
}
}
輸出結(jié)果：
before clone,b1.aInt = 11 before clone,b1.unCA = 111 ================================= after clone,b1.aInt = 11 after clone,b1.unCA = 111 ================================= after clone,b2.aInt = 22 after clone,b2.unCA = 222
可以看出，現(xiàn)在b2.unCA的改變對b1.unCA沒有產(chǎn)生影響。此時b1.unCA與b2.unCA指向了兩個不同的UnCloneA實(shí)例，而且在CloneB b2 = (CloneB)b1.clone();調(diào)用的那一刻b1和b2擁有相同的值，在這里，b1.i = b2.i = 11。
要知道不是所有的類都能實(shí)現(xiàn)深度clone的。例如，如果把上面的CloneB類中的UnCloneA類型變量改成StringBuffer類型，看一下JDK API中關(guān)于StringBuffer的說明，StringBuffer沒有重載clone()方法，更為嚴(yán)重的是StringBuffer還是一個final類，這也是說我們也不能用繼承的辦法間接實(shí)現(xiàn)StringBuffer的clone。如果一個類中包含有StringBuffer類型對象或和StringBuffer相似類的對象，我們有兩種選擇：要么只能實(shí)現(xiàn)影子clone，要么就在類的clone()方法中加一句（假設(shè)是SringBuffer對象，而且變量名仍是unCA）： o.unCA = new StringBuffer(unCA.toString()); //原來的是：o.unCA = (UnCloneA)unCA.clone();
還要知道的是除了基本數(shù)據(jù)類型能自動實(shí)現(xiàn)深度clone以外，String對象是一個例外，它c(diǎn)lone后的表現(xiàn)好象也實(shí)現(xiàn)了深度clone，雖然這只是一個假象，但卻大大方便了我們的編程。
Clone中String和StringBuffer的區(qū)別
應(yīng)該說明的是，這里不是著重說明String和StringBuffer的區(qū)別，但從這個例子里也能看出String類的一些與眾不同的地方。
下面的例子中包括兩個類，CloneC類包含一個String類型變量和一個StringBuffer類型變量，并且實(shí)現(xiàn)了clone()方法。在StrClone類中聲明了CloneC類型變量c1，然后調(diào)用c1的clone()方法生成c1的拷貝c2，在對c2中的String和StringBuffer類型變量用相應(yīng)的方法改動之后打印結(jié)果：
package com.zoer.src;
class CloneC implements Cloneable {
public String str;
public StringBuffer strBuff;
public Object clone() {
CloneC o = null;
try {
o = (CloneC) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}
public class StrClone {
public static void main(String[] a) {
CloneC c1 = new CloneC();
c1.str = new String("initializeStr");
c1.strBuff = new StringBuffer("initializeStrBuff");
System.out.println("before clone,c1.str = " + c1.str);
System.out.println("before clone,c1.strBuff = " + c1.strBuff);
CloneC c2 = (CloneC) c1.clone();
c2.str = c2.str.substring(0, 5);
c2.strBuff = c2.strBuff.append(" change strBuff clone");
System.out.println("=================================");
System.out.println("after clone,c1.str = " + c1.str);
System.out.println("after clone,c1.strBuff = " + c1.strBuff);
System.out.println("=================================");
System.out.println("after clone,c2.str = " + c2.str);
System.out.println("after clone,c2.strBuff = " + c2.strBuff);
}
}
執(zhí)行結(jié)果：
<span style="font-family:'Microsoft YaHei';"><span style="font-size:16px;">before clone,c1.str = initializeStr before clone,c1.strBuff = initializeStrBuff ================================= after clone,c1.str = initializeStr after clone,c1.strBuff = initializeStrBuff change strBuff clone ================================= after clone,c2.str = initi after clone,c2.strBuff = initializeStrBuff change strBuff clone </span></span>
打印的結(jié)果可以看出，String類型的變量好象已經(jīng)實(shí)現(xiàn)了深度clone，因?yàn)閷2.str的改動并沒有影響到c1.str！難道Java把Sring類看成了基本數(shù)據(jù)類型？其實(shí)不然，這里有一個小小的把戲，秘密就在于c2.str = c2.str.substring(0,5)這一語句！實(shí)質(zhì)上，在clone的時候c1.str與c2.str仍然是引用，而且都指向了同一個String對象。但在執(zhí)行c2.str = c2.str.substring(0,5)的時候，它作用相當(dāng)于生成了一個新的String類型，然后又賦回給c2.str。這是因?yàn)镾tring被Sun公司的工程師寫成了一個不可更改的類（immutable class），在所有String類中的函數(shù)都不能更改自身的值。
以上就是本文的全部內(nèi)容，希望對大家理解java中的深復(fù)制和淺復(fù)制有所幫助。
相關(guān)文章
java中的final關(guān)鍵字詳解及實(shí)例
這篇文章主要介紹了 java中的final關(guān)鍵字詳解及實(shí)例的相關(guān)資料,需要的朋友可以參考下2017-03-03
關(guān)于Filter中獲取請求體body后再次讀取的問題
這篇文章主要介紹了關(guān)于Filter中獲取請求體body后再次讀取的問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-03-03
Springboot配置管理Externalized?Configuration深入探究
這篇文章主要介紹了Springboot配置管Externalized?Configuration深入探究，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2024-01-01
LockSupport給我們提供了一個非常強(qiáng)大的功能，它是線程阻塞最基本的元語，他可以將一個線程阻塞也可以將一個線程喚醒，因此經(jīng)常在并發(fā)的場景下進(jìn)行使用。本文將用60行代碼實(shí)現(xiàn)手寫LockSupport，需要的可以參考一下2022-08-08
SpringBoot實(shí)現(xiàn)數(shù)據(jù)加密脫敏的示例代碼
這篇文章主要為大家學(xué)習(xí)介紹了SpringBoot如何利用注解+反射+AOP實(shí)現(xiàn)數(shù)據(jù)加密脫敏的功能，文中的示例代碼講解詳細(xì)，需要的可以參考一下2023-08-08
java:無法訪問org.springframework.boot.SpringApplication
本文主要介紹了java:無法訪問org.springframework.boot.SpringApplication,文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2025-03-03
springboot?aop里的@Pointcut()的配置方式
這篇文章主要介紹了springboot?aop里的@Pointcut()的配置方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-11-11
SpringBoot如何整合redis實(shí)現(xiàn)過期key監(jiān)聽事件
這篇文章主要介紹了SpringBoot如何整合redis實(shí)現(xiàn)過期key監(jiān)聽事件,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-09-09
java中將漢字轉(zhuǎn)換成拼音的實(shí)現(xiàn)代碼
java中將漢字轉(zhuǎn)換成拼音的實(shí)現(xiàn)代碼。需要的朋友可以過來參考下，希望對大家有所幫助2013-10-10
Java中String字符串轉(zhuǎn)具體對象的幾種常用方式
String對象可以用來存儲任何字符串類型的數(shù)據(jù),包括HTML、XML等格式的字符串,下面這篇文章主要給大家介紹了關(guān)于JavaString字符串轉(zhuǎn)具體對象的幾種常用方式,需要的朋友可以參考下2024-03-03