資訊專欄INFORMATION COLUMN
摘要：中有三種類型的對象拷貝淺拷貝深拷貝延遲拷貝。深拷貝相比于淺拷貝速度較慢并且花銷較大。意思是如果對象引用任何時候都不會被改變，那么沒必要使用深拷貝，只需要使用淺拷貝就行了。
目錄介紹
01.對象拷貝有哪些
02.理解淺拷貝
2.1 什么是淺拷貝
2.2 實現(xiàn)淺拷貝案例
03.理解深拷貝
3.1 什么是深拷貝
3.2 實現(xiàn)深拷貝案例
04.序列化進行拷貝
4.1 序列化屬于深拷貝
4.2 注意要點
4.3 序列化案例
05.延遲拷貝
06.如何選擇拷貝方式
07.數(shù)組的拷貝
7.1 基本數(shù)據(jù)類型數(shù)組
7.2 引用數(shù)據(jù)類型數(shù)組
08.集合的拷貝
8.1 集合淺拷貝
8.2 集合深拷貝
好消息博客筆記大匯總【16年3月到至今】，包括Java基礎及深入知識點，Android技術博客，Python學習筆記等等，還包括平時開發(fā)中遇到的bug匯總，當然也在工作之余收集了大量的面試題，長期更新維護并且修正，持續(xù)完善……開源的文件是markdown格式的！同時也開源了生活博客，從12年起，積累共計N篇[近100萬字，陸續(xù)搬到網(wǎng)上]，轉(zhuǎn)載請注明出處，謝謝！
鏈接地址：https://github.com/yangchong2...
如果覺得好，可以star一下，謝謝！當然也歡迎提出建議，萬事起于忽微，量變引起質(zhì)變！
01.對象拷貝有哪些對象拷貝(Object Copy)就是將一個對象的屬性拷貝到另一個有著相同類類型的對象中去。在程序中拷貝對象是很常見的，主要是為了在新的上下文環(huán)境中復用對象的部分或全部數(shù)據(jù)。
Java中有三種類型的對象拷貝：淺拷貝(Shallow Copy)、深拷貝(Deep Copy)、延遲拷貝(Lazy Copy)。
02.理解淺拷貝 2.1 什么是淺拷貝
淺拷貝是按位拷貝對象，它會創(chuàng)建一個新對象，這個對象有著原始對象屬性值的一份精確拷貝。
如果屬性是基本類型，拷貝的就是基本類型的值；如果屬性是內(nèi)存地址（引用類型），拷貝的就是內(nèi)存地址 ，因此如果其中一個對象改變了這個地址，就會影響到另一個對象。
在上圖中，SourceObject有一個int類型的屬性 "field1"和一個引用類型屬性"refObj"（引用ContainedObject類型的對象）。當對SourceObject做淺拷貝時，創(chuàng)建了CopiedObject，它有一個包含"field1"拷貝值的屬性"field2"以及仍指向refObj本身的引用。由于"field1"是基本類型，所以只是將它的值拷貝給"field2"，但是由于"refObj"是一個引用類型, 所以CopiedObject指向"refObj"相同的地址。因此對SourceObject中的"refObj"所做的任何改變都會影響到CopiedObject。
2.2 如何實現(xiàn)淺拷貝
下面來看一看實現(xiàn)淺拷貝的一個例子
public class Subject {
private String name;
public Subject(String s) {
name = s;
}
public String getName() {
return name;
}
public void setName(String s) {
name = s;
}
}
public class Student implements Cloneable {
// 對象引用
private Subject subj;
private String name;
public Student(String s, String sub) {
name = s;
subj = new Subject(sub);
}
public Subject getSubj() {
return subj;
}
public String getName() {
return name;
}
public void setName(String s) {
name = s;
}
/**
* 重寫clone()方法
*/
public Object clone() {
//淺拷貝
try {
// 直接調(diào)用父類的clone()方法
return super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
}
```
```
private void test1(){
// 原始對象
Student stud = new Student("楊充", "瀟湘劍雨");
System.out.println("原始對象: " + stud.getName() + " - " + stud.getSubj().getName());
// 拷貝對象
Student clonedStud = (Student) stud.clone();
System.out.println("拷貝對象: " + clonedStud.getName() + " - " + clonedStud.getSubj().getName());
// 原始對象和拷貝對象是否一樣：
System.out.println("原始對象和拷貝對象是否一樣: " + (stud == clonedStud));
// 原始對象和拷貝對象的name屬性是否一樣
System.out.println("原始對象和拷貝對象的name屬性是否一樣: " + (stud.getName() == clonedStud.getName()));
// 原始對象和拷貝對象的subj屬性是否一樣
System.out.println("原始對象和拷貝對象的subj屬性是否一樣: " + (stud.getSubj() == clonedStud.getSubj()));
stud.setName("小楊逗比");
stud.getSubj().setName("瀟湘劍雨大俠");
System.out.println("更新后的原始對象: " + stud.getName() + " - " + stud.getSubj().getName());
System.out.println("更新原始對象后的克隆對象: " + clonedStud.getName() + " - " + clonedStud.getSubj().getName());
}
```
輸出結果如下：
2019-03-23 13:50:57.518 24704-24704/com.ycbjie.other I/System.out: 原始對象: 楊充 - 瀟湘劍雨 2019-03-23 13:50:57.519 24704-24704/com.ycbjie.other I/System.out: 拷貝對象: 楊充 - 瀟湘劍雨 2019-03-23 13:50:57.519 24704-24704/com.ycbjie.other I/System.out: 原始對象和拷貝對象是否一樣: false 2019-03-23 13:50:57.519 24704-24704/com.ycbjie.other I/System.out: 原始對象和拷貝對象的name屬性是否一樣: true 2019-03-23 13:50:57.519 24704-24704/com.ycbjie.other I/System.out: 原始對象和拷貝對象的subj屬性是否一樣: true 2019-03-23 13:50:57.519 24704-24704/com.ycbjie.other I/System.out: 更新后的原始對象: 小楊逗比 - 瀟湘劍雨大俠 2019-03-23 13:50:57.519 24704-24704/com.ycbjie.other I/System.out: 更新原始對象后的克隆對象: 楊充 - 瀟湘劍雨大俠
可以得出的結論
在這個例子中，讓要拷貝的類Student實現(xiàn)了Clonable接口并重寫Object類的clone()方法，然后在方法內(nèi)部調(diào)用super.clone()方法。從輸出結果中我們可以看到，對原始對象stud的"name"屬性所做的改變并沒有影響到拷貝對象clonedStud，但是對引用對象subj的"name"屬性所做的改變影響到了拷貝對象clonedStud。
03.理解深拷貝 3.1 什么是深拷貝
深拷貝會拷貝所有的屬性,并拷貝屬性指向的動態(tài)分配的內(nèi)存。當對象和它所引用的對象一起拷貝時即發(fā)生深拷貝。深拷貝相比于淺拷貝速度較慢并且花銷較大。
在上圖中，SourceObject有一個int類型的屬性 "field1"和一個引用類型屬性"refObj1"（引用ContainedObject類型的對象）。當對SourceObject做深拷貝時，創(chuàng)建了CopiedObject，它有一個包含"field1"拷貝值的屬性"field2"以及包含"refObj1"拷貝值的引用類型屬性"refObj2" 。因此對SourceObject中的"refObj"所做的任何改變都不會影響到CopiedObject
3.2 實現(xiàn)深拷貝案例
下面是實現(xiàn)深拷貝的一個例子。只是在淺拷貝的例子上做了一點小改動，Subject 和CopyTest 類都沒有變化。
public class Student implements Cloneable {
// 對象引用
private Subject subj;
private String name;
public Student(String s, String sub) {
name = s;
subj = new Subject(sub);
}
public Subject getSubj() {
return subj;
}
public String getName() {
return name;
}
public void setName(String s) {
name = s;
}
/**
* 重寫clone()方法
*
*/
public Object clone() {
// 深拷貝，創(chuàng)建拷貝類的一個新對象，這樣就和原始對象相互獨立
Student s = new Student(name, subj.getName());
return s;
}
}
```
輸出結果如下：
2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 原始對象: 楊充 - 瀟湘劍雨 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 拷貝對象: 楊充 - 瀟湘劍雨 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 原始對象和拷貝對象是否一樣: false 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 原始對象和拷貝對象的name屬性是否一樣: true 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 原始對象和拷貝對象的subj屬性是否一樣: false 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 更新后的原始對象: 小楊逗比 - 瀟湘劍雨大俠 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 更新原始對象后的克隆對象: 楊充 - 瀟湘劍雨
得出的結論
很容易發(fā)現(xiàn)clone()方法中的一點變化。因為它是深拷貝，所以你需要創(chuàng)建拷貝類的一個對象。因為在Student類中有對象引用，所以需要在Student類中實現(xiàn)Cloneable接口并且重寫clone方法。
04.序列化進行拷貝 4.1 序列化屬于深拷貝可能你會問，序列化是屬于那種類型拷貝？答案是：通過序列化來實現(xiàn)深拷貝。可以思考一下，為何序列化對象要用深拷貝而不是用淺拷貝呢？
4.2 注意要點可以序列化是干什么的?它將整個對象圖寫入到一個持久化存儲文件中并且當需要的時候把它讀取回來, 這意味著當你需要把它讀取回來時你需要整個對象圖的一個拷貝。這就是當你深拷貝一個對象時真正需要的東西。請注意，當你通過序列化進行深拷貝時，必須確保對象圖中所有類都是可序列化的。
4.3 序列化案例
看一下下面案例，很簡單，只需要實現(xiàn)Serializable這個接口。Android中還可以實現(xiàn)Parcelable接口。
public class ColoredCircle implements Serializable {
private int x;
private int y;
public ColoredCircle(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "x=" + x + ", y=" + y;
}
}
private void test3() {
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
// 創(chuàng)建原始的可序列化對象
DouBi c1 = new DouBi(100, 100);
System.out.println("原始的對象 = " + c1);
DouBi c2 = null;
// 通過序列化實現(xiàn)深拷貝
ByteArrayOutputStream bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
// 序列化以及傳遞這個對象
oos.writeObject(c1);
oos.flush();
ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bin);
// 返回新的對象
c2 = (DouBi) ois.readObject();
// 校驗內(nèi)容是否相同
System.out.println("復制后的對象 = " + c2);
// 改變原始對象的內(nèi)容
c1.setX(200);
c1.setY(200);
// 查看每一個現(xiàn)在的內(nèi)容
System.out.println("查看原始的對象 = " + c1);
System.out.println("查看復制的對象 = " + c2);
} catch (IOException e) {
System.out.println("Exception in main = " + e);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (oos != null) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
輸出結果如下：
2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 原始的對象 = x=100, y=100 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 復制后的對象 = x=100, y=100 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 查看原始的對象 = x=200, y=200 2019-03-23 13:53:48.096 25123-25123/com.ycbjie.other I/System.out: 查看復制的對象 = x=100, y=100
注意：需要做以下幾件事兒:
確保對象圖中的所有類都是可序列化的
創(chuàng)建輸入輸出流
使用這個輸入輸出流來創(chuàng)建對象輸入和對象輸出流
將你想要拷貝的對象傳遞給對象輸出流
從對象輸入流中讀取新的對象并且轉(zhuǎn)換回你所發(fā)送的對象的類
得出的結論
在這個例子中，創(chuàng)建了一個DouBi對象c1然后將它序列化 (將它寫到ByteArrayOutputStream中). 然后我反序列化這個序列化后的對象并將它保存到c2中。隨后我修改了原始對象c1。然后結果如你所見，c1不同于c2，對c1所做的任何修改都不會影響c2。
注意，序列化這種方式有其自身的限制和問題：因為無法序列化transient變量, 使用這種方法將無法拷貝transient變量。再就是性能問題。創(chuàng)建一個socket, 序列化一個對象, 通過socket傳輸它, 然后反序列化它，這個過程與調(diào)用已有對象的方法相比是很慢的。所以在性能上會有天壤之別。如果性能對你的代碼來說是至關重要的，建議不要使用這種方式。它比通過實現(xiàn)Clonable接口這種方式來進行深拷貝幾乎多花100倍的時間。
05.延遲拷貝延遲拷貝是淺拷貝和深拷貝的一個組合，實際上很少會使用。這個以前幾乎都沒聽說過，后來看書才知道有這么一種拷貝！
當最開始拷貝一個對象時，會使用速度較快的淺拷貝，還會使用一個計數(shù)器來記錄有多少對象共享這個數(shù)據(jù)。當程序想要修改原始的對象時，它會決定數(shù)據(jù)是否被共享（通過檢查計數(shù)器）并根據(jù)需要進行深拷貝。
延遲拷貝從外面看起來就是深拷貝，但是只要有可能它就會利用淺拷貝的速度。當原始對象中的引用不經(jīng)常改變的時候可以使用延遲拷貝。由于存在計數(shù)器，效率下降很高，但只是常量級的開銷。而且, 在某些情況下, 循環(huán)引用會導致一些問題。
06.如何選擇拷貝方式如果對象的屬性全是基本類型的，那么可以使用淺拷貝。
如果對象有引用屬性，那就要基于具體的需求來選擇淺拷貝還是深拷貝。
意思是如果對象引用任何時候都不會被改變，那么沒必要使用深拷貝，只需要使用淺拷貝就行了。如果對象引用經(jīng)常改變，那么就要使用深拷貝。沒有一成不變的規(guī)則，一切都取決于具體需求。
07.數(shù)組的拷貝數(shù)組除了默認實現(xiàn)了clone()方法之外，還提供了Arrays.copyOf方法用于拷貝，這兩者都是淺拷貝。
7.1 基本數(shù)據(jù)類型數(shù)組
如下所示
public void test4() {
int[] lNumbers1 = new int[5];
int[] rNumbers1 = Arrays.copyOf(lNumbers1, lNumbers1.length);
rNumbers1[0] = 1;
boolean first = lNumbers1[0] == rNumbers1[0];
Log.d("小楊逗比", "lNumbers2[0]=" + lNumbers1[0] + ",rNumbers2[0]=" + rNumbers1[0]+"---"+first);
int[] lNumbers3 = new int[5];
int[] rNumbers3 = lNumbers3.clone();
rNumbers3[0] = 1;
boolean second = lNumbers3[0] == rNumbers3[0];
Log.d("小楊逗比", "lNumbers3[0]=" + lNumbers3[0] + ",rNumbers3[0]=" + rNumbers3[0]+"---"+second);
}
打印結果如下所示
2019-03-25 14:28:09.907 30316-30316/org.yczbj.ycrefreshview D/小楊逗比: lNumbers2[0]=0,rNumbers2[0]=1---false 2019-03-25 14:28:09.907 30316-30316/org.yczbj.ycrefreshview D/小楊逗比: lNumbers3[0]=0,rNumbers3[0]=1---false7.2 引用數(shù)據(jù)類型數(shù)組
如下所示
public static void test5() {
People[] lNumbers1 = new People[5];
lNumbers1[0] = new People();
People[] rNumbers1 = lNumbers1;
boolean first = lNumbers1[0].equals(rNumbers1[0]);
Log.d("小楊逗比", "lNumbers1[0]=" + lNumbers1[0] + ",rNumbers1[0]=" + rNumbers1[0]+"--"+first);
People[] lNumbers2 = new People[5];
lNumbers2[0] = new People();
People[] rNumbers2 = Arrays.copyOf(lNumbers2, lNumbers2.length);
boolean second = lNumbers2[0].equals(rNumbers2[0]);
Log.d("小楊逗比", "lNumbers2[0]=" + lNumbers2[0] + ",rNumbers2[0]=" + rNumbers2[0]+"--"+second);
People[] lNumbers3 = new People[5];
lNumbers3[0] = new People();
People[] rNumbers3 = lNumbers3.clone();
boolean third = lNumbers3[0].equals(rNumbers3[0]);
Log.d("小楊逗比", "lNumbers3[0]=" + lNumbers3[0] + ",rNumbers3[0]=" + rNumbers3[0]+"--"+third);
}
public static class People implements Cloneable {
int age;
Holder holder;
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public static class Holder {
int holderValue;
}
}
打印日志如下
2019-03-25 14:53:17.054 31093-31093/org.yczbj.ycrefreshview D/小楊逗比: lNumbers1[0]=org.yczbj.ycrefreshview.MainActivity$People@46a2c18,rNumbers1[0]=org.yczbj.ycrefreshview.MainActivity$People@46a2c18--true 2019-03-25 14:53:17.054 31093-31093/org.yczbj.ycrefreshview D/小楊逗比: lNumbers2[0]=org.yczbj.ycrefreshview.MainActivity$People@d344671,rNumbers2[0]=org.yczbj.ycrefreshview.MainActivity$People@d344671--true 2019-03-25 14:53:17.054 31093-31093/org.yczbj.ycrefreshview D/小楊逗比: lNumbers3[0]=org.yczbj.ycrefreshview.MainActivity$People@91e9c56,rNumbers3[0]=org.yczbj.ycrefreshview.MainActivity$People@91e9c56--true08.集合的拷貝
集合的拷貝也是我們平時經(jīng)常會遇到的，一般情況下，我們都是用淺拷貝來實現(xiàn)，即通過構造函數(shù)或者clone方法。
8.1 集合淺拷貝
構造函數(shù)和 clone() 默認都是淺拷貝
public static void test6() {
ArrayList lPeoples = new ArrayList<>();
People people1 = new People();
lPeoples.add(people1);
Log.d("小楊逗比", "lPeoples[0]=" + lPeoples.get(0));
ArrayList rPeoples = (ArrayList) lPeoples.clone();
Log.d("小楊逗比", "rPeoples[0]=" + rPeoples.get(0));
boolean b = lPeoples.get(0).equals(rPeoples.get(0));
Log.d("小楊逗比", "比較兩個對象" + b);
}
public static class People implements Cloneable {
int age;
Holder holder;
@Override
protected Object clone() {
try {
People people = (People) super.clone();
people.holder = (People.Holder) this.holder.clone();
return people;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public static class Holder implements Cloneable {
int holderValue;
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
}
打印日志
2019-03-25 14:56:56.931 31454-31454/org.yczbj.ycrefreshview D/小楊逗比: lPeoples[0]=org.yczbj.ycrefreshview.MainActivity$People@46a2c18 2019-03-25 14:56:56.931 31454-31454/org.yczbj.ycrefreshview D/小楊逗比: rPeoples[0]=org.yczbj.ycrefreshview.MainActivity$People@46a2c18 2019-03-25 14:56:56.931 31454-31454/org.yczbj.ycrefreshview D/小楊逗比: 比較兩個對象true8.2 集合深拷貝
在某些特殊情況下，如果需要實現(xiàn)集合的深拷貝，那就要創(chuàng)建一個新的集合，然后通過深拷貝原先集合中的每個元素，將這些元素加入到新的集合當中。
public static void test7() {
ArrayList lPeoples = new ArrayList<>();
People people1 = new People();
people1.holder = new People.Holder();
lPeoples.add(people1);
Log.d("小楊逗比", "lPeoples[0]=" + lPeoples.get(0));
ArrayList rPeoples = new ArrayList<>();
for (People people : lPeoples) {
rPeoples.add((People) people.clone());
}
Log.d("小楊逗比", "rPeoples[0]=" + rPeoples.get(0));
boolean b = lPeoples.get(0).equals(rPeoples.get(0));
Log.d("小楊逗比", "比較兩個對象" + b);
}
public static class People implements Cloneable {
int age;
Holder holder;
@Override
protected Object clone() {
try {
People people = (People) super.clone();
people.holder = (People.Holder) this.holder.clone();
return people;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
public static class Holder implements Cloneable {
int holderValue;
@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
}
打印日志
2019-03-25 15:00:54.610 31670-31670/org.yczbj.ycrefreshview D/小楊逗比: lPeoples[0]=org.yczbj.ycrefreshview.MainActivity$People@46a2c18 2019-03-25 15:00:54.610 31670-31670/org.yczbj.ycrefreshview D/小楊逗比: rPeoples[0]=org.yczbj.ycrefreshview.MainActivity$People@d344671 2019-03-25 15:00:54.610 31670-31670/org.yczbj.ycrefreshview D/小楊逗比: 比較兩個對象false其他介紹 01.關于博客匯總鏈接
1.技術博客匯總
2.開源項目匯總
3.生活博客匯總
4.喜馬拉雅音頻匯總
5.其他匯總
02.關于我的博客我的個人站點：www.yczbj.org，www.ycbjie.cn
github：https://github.com/yangchong211
知乎：https://www.zhihu.com/people/...
簡書：http://www.jianshu.com/u/b7b2...
csdn：http://my.csdn.net/m0_37700275
喜馬拉雅聽書：http://www.ximalaya.com/zhubo...
開源中國：https://my.oschina.net/zbj161...
泡在網(wǎng)上的日子：http://www.jcodecraeer.com/me...
郵箱：yangchong211@163.com
阿里云博客：https://yq.aliyun.com/users/a... 239.headeruserinfo.3.dT4bcV
segmentfault頭條：https://segmentfault.com/u/xi...
掘金：https://juejin.im/user/593943...
文章版權歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址：http://specialneedsforspecialkids.com/yun/73911.html
摘要：本文解釋中深拷貝和淺拷貝的區(qū)別。深拷貝深拷貝指遞歸的復制對象的屬性給新對象。有些時候一層的深拷貝被認為是淺拷貝，比如的值是一個對象，淺拷貝出來的新對象直接引用了原對象的對象，所以也會相互影響的。 本文解釋javascript中深拷貝和淺拷貝的區(qū)別。 淺拷貝/Shallow Copy 淺拷貝指拷貝了引用值。 var original = {prop1 : Prop1, prop2 : p...
摘要：深拷貝和淺拷貝的區(qū)別背景最近在用框架寫頁面，賦值給中的對象時會出現(xiàn)一個問題，賦值和被賦值對象之中任何一個有變化，另一個也會隨之變化。 深拷貝和淺拷貝的區(qū)別 背景：最近在用vue框架寫頁面，賦值給Vue.$data中的對象時會出現(xiàn)一個問題，賦值和被賦值對象之中任何一個有變化，另一個也會隨之變化。例如： var b = { foo: 123 }; var vm = new Vue(...
摘要：關于深拷貝和淺拷貝從原理看淺拷貝拷貝一層，對象級別的則拷貝引用深拷貝拷貝多層，每個層級的屬性都會拷貝從現(xiàn)象看復制了，被修改后，隨變化而變化淺拷貝不變深拷貝深拷貝針對的復雜的類型數(shù)據(jù)如直接賦值的單層拷貝，如，雖然不受的影響，但是這也不算做 關于深拷貝和淺拷貝 從原理看： 淺拷貝：拷貝一層，對象級別的則拷貝引用 深拷貝：拷貝多層，每個層級的屬性都會拷貝 從現(xiàn)象看：A復制了B，B被修改后...
摘要：對于而言，情況可能會有點小復雜，因為一切皆為對象，所以的普通賦值深拷貝和淺拷貝之間都是有細微區(qū)別的。二下的他們在中，對象的賦值和傳遞都是引用。 一、深拷貝與淺拷貝 ??深拷貝：賦值時值完全復制，完全的copy，對其中一個作出改變，不會影響另一個 ??淺拷貝：賦值時，引用賦值，相當于取了一個別名。對其中一個修改，會影響另一個 ??對于PHP而言，= 賦值時，普通對象是深拷貝，但對對象來說...
閱讀 929·2023-04-25 23:40
閱讀 3710·2021-11-22 15:22
閱讀 3549·2021-10-09 09:44
閱讀 3403·2021-09-23 11:52
閱讀 1257·2021-09-22 15:43
閱讀 785·2021-09-10 10:51
閱讀 2206·2021-09-06 15:02
閱讀 3198·2021-09-06 15:02
