java中的浅拷贝和深拷贝

          java中的拷贝是什么 ？就是用Object中的clone()拷贝一个对象

在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

那请问new创建一个对象和clone复制一个对象有什么区别吗？
        new操作符的本意是分配内存。程序执行到new操作符时， 首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象。而clone在第一步是和new相似的， 都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域， 填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。

简单举一个栗子吧：

package fuxi; class Student{ int age; String name; public Student(String name,int age) { this.name=name; this.age=age; } } public class One { public static void main(String args[]) { Student student1=new Student("小蒋", 21); Student student2=student1; System.out.println("学生1地址"+student1); System.out.println("学生2地址"+student2); } }

输出：

意思就是说 如果是引用 直接复制的话 只是把引用给复制一遍 意思就是 student1和student2的引用值是相同的 代表同一个对象。

浅拷贝：

浅拷贝（浅复制、浅克隆）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。

MainObject1是一个对象 而MainObject2是MainObject1的浅克隆对象
Field1 Field2 是int ContainObject1是对象
如果是int之类的基本类型 则是直接赋值代表两个不同的变量 但是内容相同 操作一个对另一个不影响
如果是引用类型如对象之类的 那么操作MainObject1的ContainObject1就会影响MainObject2中的ContainObject2 因为他俩引用是指向同一个对象
注意：String是特殊情况 String 类型在传递时其实也是值传递，因为 String 类型是不可变对象。 所以如果ContainObject1是String类型 那么改变MainObject1的ContainObject1不会影响MainObject2中的ContainObject2 而是指向新的String值 具体的可以看为什么String是不可变的

栗子：

package fuxi; class Person { int age; String name; public Person(String name,int age) { this.name=name; this.age=age; } public void setAge(int a) { age=a; } public void setName(String name) { this.name=name; } } public class One implements Cloneable { String bookName; double price; Person author; public One(String bn, double price, Person author) { bookName = bn; this.price = price; this.author = author; } public Object clone() { Object b = null; try { b = super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return (One)b; } public static void main(String args[]) { Person p = new Person("Dream", 34); One book1 = new One("Java开发", 30.00, p); One book2 = (One) book1.clone(); book2.price = 44.00; book2.author.setAge(45); book2.author.setName("Fish"); book2.bookName = "Android开发"; System.out.println("age = " + book1.author.age + " name = " + book1.bookName + " price = " + book1.price); System.out.print("age = " + book2.author.age + " name = " + book2.bookName + " price = " + book2.price); } }

结果：

age = 45 name = Java开发 price = 30.0 age = 45 name = Android开发 price = 44.0

从结果中发现在改变 book2 对象的 name 和 price 属性时 book1 的属性并不会跟随改变，当改变 book2 对象的 author 属性时 book1 的 author 对象的属性也改变了，说明 author 是浅拷贝，和 book1 的 author 是使用同一引用。

 1.为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。 2.在派生类中覆盖基类的clone()方法，并声明为public。 （Object类中的clone()方法是protected的）。在子类重写的时候，可以扩大访问修饰符的范围 3.在派生类的clone()方法中，调用super.clone()。 因为在运行时刻，Object类中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间 并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。 4.在派生类中实现Cloneable接口。这个接口中没有什么方法，只是说明作用。 注意：继承自java.lang.Object类的clone()方法是浅复制。

clone（）方法是复制对象的最快方法。这个过程需要更少的步骤来完成。
默认情况下，clone（）方法提供对象的浅表副本; 即，如果我们调用super.clone（），那么它是一个浅拷贝。
clone()方法将对象复制了一份并返回给调用者。
①对任何的对象x，都有x.clone() != x;//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()== x.getClass();//克隆对象与原对象的类型一样

总结 ：浅拷贝 ：浅拷贝对象要继承Cloneable 然后重写clone 直接返回（对象）super.clone即可

深拷贝：

深拷贝（深复制、深克隆）：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。

那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。

换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

直接看图 是全新的 对象 深拷贝后
源对象和拷贝对象之间互不影响。无论字段是否是应用类型还是原始数据类型。
那么如何实现深拷贝呢？
其实 很简单：

即 原来的person浅拷贝处理：

class Person implements Cloneable{ int age; String name; public Person(String name,int age) { this.name=name; this.age=age; } public void setAge(int a) { age=a; } public void setName(String name) { this.name=name; } public Object clone() { Object b = null; try { b = super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return (Person)b; } }

加上这句话就可以了

book2.author =(Person)author.clone(); //将Person对象进行拷贝，Person对象需进行了拷贝

即：

One book2 = (One) book1.clone(); book2.author=(Person)p.clone();

上面是用 clone() 方法实现深拷贝，传统重载clone()方法，但当类中有很多引用时，比较麻烦。 当然我们还有一种深拷贝方法，就是将对象 序列化 。

把对象写到流里的过程是序列化（Serilization）过程；而把对象从流中读出来的反序列化（Deserialization）过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。

在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。

public Object deepClone() { //将对象写到流里 ByteArrayOutoutStream bo=new ByteArrayOutputStream(); ObjectOutputStream oo=new ObjectOutputStream(bo); oo.writeObject(this); //从流里读出来 ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray()); ObjectInputStream oi=new ObjectInputStream(bi); return(oi.readObject()); }

注意： 如果拷贝类里面有类对象的话 那么那个类也得是实现Serializable接口
然后拷贝对象的时候调用deepClone（）方法 来代替clone方法

One book2 =(One)book1.deepClone();

完整代码如下 ： 不难 耐心看完

package fuxi; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.OptionalDataException; import java.io.OutputStream; import java.io.Serializable; class Person implements Serializable { int age; String name; public Person(String name,int age) { this.name=name; this.age=age; } public void setAge(int a) { age=a; } public void setName(String name) { this.name=name; } } public class One implements Serializable { String bookName; double price; Person author; public One(String bn, double price, Person author) { bookName = bn; this.price = price; this.author = author; } public Object deepClone() throws IOException, OptionalDataException, ClassNotFoundException { // 将对象写到流里 OutputStream bo = new ByteArrayOutputStream(); ObjectOutputStream oo = new ObjectOutputStream(bo); oo.writeObject(this); // 从流里读出来 InputStream bi = new ByteArrayInputStream(((ByteArrayOutputStream) bo).toByteArray()); ObjectInputStream oi = new ObjectInputStream(bi); return (oi.readObject()); } public static void main(String args[]) throws OptionalDataException, ClassNotFoundException, IOException { Person p = new Person("Dream", 34); One book1 = new One("Java开发", 30.00, p); One book2 =(One)book1.deepClone(); book2.price = 44.00; book2.author.setAge(45); book2.author.setName("Fish"); book2.bookName = "Android开发"; System.out.println("age = " + book1.author.age + " name = " + book1.bookName + " price = " + book1.price); System.out.print("age = " + book2.author.age + " name = " + book2.bookName + " price = " + book2.price); } }

输出是：

age = 34 name = Java开发 price = 30.0 age = 45 name = Android开发 price = 44.0

总结：
浅拷贝：

深拷贝：

浅拷贝：
浅拷贝对象需要继承Cloneable接口 重写clone 返回super.clone 并且把protect改为public 依靠clone实现拷贝
调用： Student s2 = (Student)s1.clone();即可

深拷贝：
源对象和拷贝对象之间互不影响。无论字段是否是应用类型还是原始数据类型。
深拷贝对象需要继承Serializable接口 依靠序列化 自定义方法 来写入读出流
调用：One book2 =(One)book1.deepClone();
注意：序列化的时候考虑transient 因为这个修饰符可以 使被修饰的变量不被序列化 意思就是：不能序列化一个transient变量。
(具体可以参考：序列化）

使用场景有：

使用浅拷贝：对象只有原始数据类型字段；有引用类型的字段，但从不更改它。 使用深拷贝：有引用类型的字段，且经常被修改。

它非常简单，如果对象只有原始字段，那么显然你会去浅层复制，但是如果对象引用了其他对象，那么根据请求，应该选择浅拷贝或深拷贝。我的意思是，如果引用不随时修改，那么进行深层复制就没有意义了。你可以选择浅拷贝。但如果参考文件经常被修改，那么您需要进行深度复制。再次没有硬性规定，这一切都取决于要求。

问：什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？

答：在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

题外话：
如果是单例模式，你以这种方式进行深拷贝，则它就不再是单例模式了。

参考：
https://blog.csdn.net/zhangjg_blog/article/details/18369201
https://www.jianshu.com/p/8c74edbb46c0