Question

什么是深拷贝和浅拷贝

Answer 1

浅拷贝就是指对象复制的时候只复制一层；深拷贝是指复制对象的所有层级。

深拷贝和浅拷贝，主要是对象发生复制的时候，根据复制的层级不同来区分的。很多人在这里经常变量赋值发生混淆。对于JavaScript数组等复杂的数据类型来说，将其赋值给其它变量，其实只是复制了对象的地址给它，两个变量指向的是同一个对象，因此普通的赋值既不是深拷贝也不是浅拷贝。

深拷贝和浅拷仔芹贝需要注意的地方就是可变元素的拷贝：

在浅拷贝时，拷贝出来的新对象的地址和原对象是不一样的，但是新对象里面的可变元素（如列表）的地址和原对渗戚做象里的可变元素的地址是相同的，也就是说浅拷贝它拷贝的是浅层次的数据结构（不可变元素），对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去。

而是和原对象里的可变元素指向同一个地址，所以在新对象或原对象里对这个可变元素做修改时，两个对象丛衡是同时改变的，但是深拷贝不会这样，这个是浅拷贝相对于深拷贝最根本的区别。

Answer 2

JAVA技术之深拷贝与浅拷贝 　　在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象空穗卜B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在Java语言中，用简单的赋斗穗值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。　　Java的所有类都默认继承java.lang.Object类，在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点：一是拷贝对象返回的是一个新对象，而不是一个引用。二是拷贝对象与用new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，族旅而不是对象的初始信息。　　怎样应用clone()方法？　　一个很典型的调用clone()代码如下：　　01class CloneClass implements Cloneable{　　02 public int aInt;　　03 public Object clone(){　　04 CloneClass o = null;　　05 try{　　06 o = (CloneClass)super.clone();　　07 }catch(CloneNotSupportedException e){　　08 e.printStackTrace();　　09 }　　10 return o;　　11 }　　12}　　有三个值得注意的地方，一是希望能实现clone功能的CloneClass类实现了Cloneable接口，这个接口属于java.lang包，java.lang包已经被缺省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone()方法。最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。　　应该说第三点是最重要的，仔细观察一下Object类的clone()一个native方法，native方法的效率一般来说都是远高于java中的非native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了clone功能。对于第二点，也要观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法，必须继承Object类，在Java中所有的类是缺省继承Object类的，也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为了让其它类能调用这个clone类的clone()方法，重载之后要把clone()方法的属性设置为public。　　那么clone类为什么还要实现Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了super.Clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常。　　注意：1.所有的数组都被视为实现接口 Cloneable。　　2.Object 类本身不实现接口 Cloneable，所以在类为 Object 的对象上调用 clone 方法将会导致在运行时抛出异常。　　以上是clone的最基本的步骤，想要完成一个成功的clone，还要了解什么是"影子clone"和"深度clone"。　　什么是影子clone？　　下面的例子包含三个类UnCloneA，CloneB，CloneMain。CloneB类包含了一个UnCloneA的实例和一个int类型变量，并且重载clone()方法。CloneMain类初始化UnCloneA类的一个实例b1，然后调用clone()方法生成了一个b1的拷贝b2。最后考察一下b1和b2的输出：　　01package clone;　　02class UnCloneA {　　03 private int i;　　04 public UnCloneA(int ii) { i = ii; }　　05 public void doubleValue() { i *= 2; }　　06 public String toString() {　　07 return Integer.toString(i);　　08 }　　09}　　10class CloneB implements Cloneable{　　11 public int aInt;　　12 public UnCloneA unCA = new UnCloneA(111);　　13 public Object clone(){　　14 CloneB o = null;　　15 try{　　16 o = (CloneB)super.clone();　　17 }catch(CloneNotSupportedException e){　　18 e.printStackTrace();　　19 }　　20 return o;　　21 }　　22}　　23public class CloneMain {　　24 public static void main(String[] a){　　25 CloneB b1 = new CloneB();　　26 b1.aInt = 11;　　27 System.out.println("before clone,b1.aInt = "+ b1.aInt);　　28 System.out.println("before clone,b1.unCA = "+ b1.unCA);　　29　　30 CloneB b2 = (CloneB)b1.clone();　　31 b2.aInt = 22;　　32 b2.unCA.doubleValue();　　33 System.out.println("=================================");　　34 System.out.println("after clone,b1.aInt = "+ b1.aInt);　　35 System.out.println("after clone,b1.unCA = "+ b1.unCA);　　36 System.out.println("=================================");　　37 System.out.println("after clone,b2.aInt = "+ b2.aInt);　　38 System.out.println("after clone,b2.unCA = "+ b2.unCA);　　39 }　　40}　　41　　42　　43　　44　　输出的结果说明int类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致，int类型是真正的被clone了，因为改变了b2中的aInt变量，对b1的aInt没有产生影响，也就是说，b2.aInt与b1.aInt已经占据了不同的内存空间，b2.aInt是b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA，很明显，b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用！从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量，我们知道它们保存的仅仅是对象的引用，这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。　　大多时候，这种clone的结果往往不是我们所希望的结果，这种clone也被称为"影子clone"。要想让b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作为初始信息，就要实现深度clone。　　怎么进行深度clone？　　把上面的例子改成深度clone很简单，需要两个改变：一是让UnCloneA类也实现和CloneB类一样的clone功能（实现Cloneable接口，重载clone()方法）。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();　　程序如下：　　01package clone.ext;　　02class UnCloneA implements Cloneable{　　03 private int i;　　04 public UnCloneA(int ii) { i = ii; }　　05 public void doubleValue() { i *= 2; }　　06 public String toString() {　　07 return Integer.toString(i);　　08 }　　09 public Object clone(){　　10 UnCloneA o = null;　　11 try{　　12 o = (UnCloneA)super.clone();　　13 }catch(CloneNotSupportedException e){　　14 e.printStackTrace();　　15 }　　16 return o;　　17 }　　18}　　19class CloneB implements Cloneable{　　20 public int aInt;　　21 public UnCloneA unCA = new UnCloneA(111);　　22 public Object clone(){　　23 CloneB o = null;　　24 try{　　25 o = (CloneB)super.clone();　　26 }catch(CloneNotSupportedException e){　　27 e.printStackTrace();　　28 }　　29 o.unCA = (UnCloneA)unCA.clone();　　30 return o;　　31 }　　32}　　33public class CloneMain {　　34 public static void main(String[] a){　　35 CloneB b1 = new CloneB();　　36 b1.aInt = 11;　　37 System.out.println("before clone,b1.aInt = "+ b1.aInt);　　38 System.out.println("before clone,b1.unCA = "+ b1.unCA);　　39　　40 CloneB b2 = (CloneB)b1.clone();　　41 b2.aInt = 22;　　42 b2.unCA.doubleValue();　　43 System.out.println("=================================");　　44 System.out.println("after clone,b1.aInt = "+ b1.aInt);　　45 System.out.println("after clone,b1.unCA = "+ b1.unCA);　　46 System.out.println("=================================");　　47 System.out.println("after clone,b2.aInt = "+ b2.aInt);　　48 System.out.println("after clone,b2.unCA = "+ b2.unCA);　　49 }　　50}　　51　　可以看出，现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例，而且在CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的值，在这里，b1.i = b2.i = 11。　　要知道不是所有的类都能实现深度clone的。例如，如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型，看一下JDK API中关于StringBuffer的说明，StringBuffer没有重载clone()方法，更为严重的是StringBuffer还是一个final类，这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和StringBuffer相似类的对象，我们有两种选择：要么只能实现影子clone，要么就在类的clone()方法中加一句（假设是SringBuffer对象，而且变量名仍是unCA）： o.unCA = new StringBuffer(unCA.toString()); //原来的是：o.unCA = (UnCloneA)unCA.clone();　　还要知道的是除了基本数据类型能自动实现深度clone以外，String对象是一个例外，它clone后的表现好象也实现了深度clone，虽然这只是一个假象，但却大大方便了我们的编程。]

Answer 3

浅拷贝就是成员数据之间的一一赋值：把值赋给一一赋给要拷贝的值。但是可能会早郑有这样的情况：对象还包含资源，这里的资源可以值堆资源，或者一个文件。。当值拷贝的时候，两个对象猛睁仿就有用共同的资源，同时对资源可以访问，这样就会出问题。深拷贝就是用来解决这样的问题的，它把资源也赋值一次，使对象拥有不同的资源，但资源的内容是一样的。对枝纤于堆资源来说，就是在开辟一片堆内存，把原来的内容拷贝。
如果你拷贝的对象中引用了某个外部的内容（比如分配在堆上的数据），那么在拷贝这个对象的时候，让新旧两个对象指向同一个外部的内容，就是浅拷贝；如果在拷贝这个对象的时候为新对象制作了外部对象的独立拷贝，就是深拷贝
引用和指针的语义是相似的，引用是不可改变的指针，指针是可以改变的引用。其实都是实现了引用语义。

Answer 4

1、Python深浅拷贝概念
在Python中，当进行赋值操作时，实际上是将一个对象的应用赋给了一个变量，因此这两个变量指向的是同一个对象。如果我们需要复制一个对象，那么就需要使用拷贝操作。
浅复制是指新建一个对象，然后将原始对象的引用复制给新对象。由于新对象与原始对象同一内存地址，因此一个对象的值被修改后，另一个对象的值也会受到影响。浅拷贝只复制对象的一层内容。
递归复制原始对象及其子对象的所有内容，从而创建一个新的对象，这就是深度复制。由于新对象与原始对象并无共享内存地址，故而二者完全独立，因此更改其中一个对象的值并不会影响另一脊洞举个对象的值。
2、Python深浅拷颤汪贝使用场景
浅拷贝适合于对象层次结构较浅的情况，比如列表、元组、字典等简单对象的复制。如果对象的元素全部为不可变类型，则可以使用浅拷贝来复制该对象。
如果对象层次结构比较复杂，例如嵌套列表的列表或嵌套字典的字典，那么深拷贝就是一个合适的选择。如果一个对象的元素包含可变对象，那么在需要进行拷贝时必须使用深拷贝。
3、Python深浅拷贝注意事项
对于不可变对象，浅拷贝和深拷贝都是相同的。
浅拷贝只会复制可变对象的一层内容，而不会递归复制可变对象包含的子对象。如果需要递归复制子对象，必须使用深拷贝。
当一个对象包含循环引用时樱碧，尝试进行深复制可能会导致无限递归，从而导致程序崩溃。因此，在使用深拷贝时，必须小心处理包含循环引用的对象。
在使用深拷贝时，如果对象的层次结构比较复杂，可能会导致性能问题，因此必须小心使用深拷贝。

Answer 5

1、Python深浅拷贝概念
在Python中，当进行赋值操作时，实际上是将一个对象的应用赋给了一个变量，因此这两个变量指向的是同一个对象。如果我们需要复制一个对象，那么就需要使用拷贝操作。
浅复制是指新建一个对象，然后将原始对象的引用复制给新对象。由于新对象与原始对象同一内存地址，因此一个对象的值被修改后，另一个对象的值也会受到影响。浅拷贝只复制对象的一层内容。
递归复制原始对象及其子对象的所有内容，从而创建一个新的对象，这就是深度复制。由于新对象与原始对象并无共享内存地址，故而二者完全独立，因此更改其中一个对象的值并不会影响另一脊洞举个对象的值。
2、Python深浅拷颤汪贝使用场景
浅拷贝适合于对象层次结构较浅的情况，比如列表、元组、字典等简单对象的复制。如果对象的元素全部为不可变类型，则可以使用浅拷贝来复制该对象。
如果对象层次结构比较复杂，例如嵌套列表的列表或嵌套字典的字典，那么深拷贝就是一个合适的选择。如果一个对象的元素包含可变对象，那么在需要进行拷贝时必须使用深拷贝。
3、Python深浅拷贝注意事项
对于不可变对象，浅拷贝和深拷贝都是相同的。
浅拷贝只会复制可变对象的一层内容，而不会递归复制可变对象包含的子对象。如果需要递归复制子对象，必须使用深拷贝。
当一个对象包含循环引用时樱碧，尝试进行深复制可能会导致无限递归，从而导致程序崩溃。因此，在使用深拷贝时，必须小心处理包含循环引用的对象。
在使用深拷贝时，如果对象的层次结构比较复杂，可能会导致性能问题，因此必须小心使用深拷贝。