Java深拷贝和浅拷贝（深克隆和浅克隆）

Java中创建对象有两种方式：

通过new操作符创建一个对象
通过clone方法来复制一个对象
使用反序列化来创建一个对象
通过使用Class类的newInstance方法来创建一个对象
使用Constructor类的newInstance方法来创建一个对象

第一种方法，通过new操作符来创建一个对象，分配内存，调用构造函数来填充各个域，这是我们最熟悉的；第二种clone也是分配内存，分配的内存和被clone对象相同，然后再使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部；第三种序列化和反序列化一个对象，jvm会给我们创建一个单独的对象。在反序列化时，jvm创建对象并不会调用任何构造函数。第四种和第五种都是通过反射机制来创建一个对象，这里就不细说了，接下来详细说一下前三种情况。

在说之前先说一下引用拷贝

引用拷贝

public class Test {
	
	public static void main(String[] args) { Person person = new Person(); Person person1 = person; System.out.println(person.hashCode());//1426511082 System.out.println(person1.hashCode());//1426511082 } } class Person{ }

输出结果：

1426511082
1426511082

有上述代码打印哈希值可知，person和person1指向一个内存地址，所以它们是一个对象，这里只是拷贝了引用而已。

浅拷贝

要实现对象的拷贝，那么要拷贝的这个对象的类必须实现Cloneable接口，并且重写clone()方法，由于clone()方法在object类中被定义为protected，由于protected对本包和所有子类可以访问，所以这里无法调用到clone()方法，因而我们必须将覆写的clone()方法声明为public

public class Test {
	
	public static void main(String[] args) throws CloneNotSupportedException { Car car = new Car("red"); Person person = new Person("zhang",car); Person person1 = (Person)person.clone(); System.out.println(person.hashCode() == person1.hashCode());//false System.out.println(person.getCar().hashCode() == person1.getCar().hashCode());//true System.out.println(person.getName().hashCode() == person1.getName().hashCode());//true person1.getCar().setColor("blue"); person1.setName("liu"); System.out.println(person.getCar().getColor());//blue System.out.println(person1.getCar().getColor());//blue System.out.println(person.getName());//zhang System.out.println(person1.getName());//liu } } class Person implements Cloneable{ private String name; private Car car; public Person(String name,Car car) { this.car = car; this.name = name; } public Object clone() throws CloneNotSupportedException { // TODO Auto-generated method stub return super.clone(); } 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; } } class Car{ private String color; public Car(String color) { this.color = color; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } }

上述运行结果为:

false
true
true
blue
blue
zhang
liu

第一个true表明person这个对象我们已经复制成功了，person和person1不是指向一个内存，perosn.name与person.name这是因为在Car类中我们并没有覆写clone()方法，这就是浅拷贝。
第二个true说明了person.car与person1.car指向同一个地址，再将person1的car的属性值为blue后，person的也随之改变，这个也验证了我们所说的person.car与person1.car指向同一个地址
第三个true说明了perosn.name与person.name指向同一个地址，但是这时我们发现，person.name与person1.name不是一个值了，说明我们拷贝成功了，这是为什么，这不和car属性前后矛盾了？这是因为String类不是基本数据类型，而且直接被定义为final,而且没有Cloneable接口，所以我们无法对它像其他pojo类一样进行深拷贝，但这并不影响，因为String类是final,每次修改它都是重新创建新对象。
假设person还有一个基本数据类型属性，例如int类型的age属性的话，覆写了clone()方法后，直接拷贝是拷贝值，和String一样，当值发生变化的时候会重新创建。

我们总结一下，浅拷贝又称为浅复制，浅克隆，浅拷贝是指拷贝时只拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用所指向的对象，拷贝出来的对象的所有变量的值都含有与原来对象相同的值，而所有对其他对象的引用都指向原来的对象，简单地说，浅拷贝只是拷贝了对象本身，但是对象所引用的所有对象并没有复制，只是复制了这个对象的引用，比如这儿的Car。

深拷贝

我们现在将Car类进行clone覆写，并且将Person中的clone()进行改动，让Person可以实现对Car属性的深克隆

public class Test {
	
	public static void main(String[] args) throws CloneNotSupportedException { Car car = new Car("red"); Person person = new Person("zhang",car); Person person1 = (Person)person.clone(); System.out.println(person.hashCode() == person1.hashCode());//false System.out.println(person.getCar().hashCode() == person1.getCar().hashCode());//false System.out.println(person.getName().hashCode() == person1.getName().hashCode());//true person1.getCar().setColor("blue"); person1.setName("liu"); System.out.println(person.getCar().getColor());//red System.out.println(person1.getCar().getColor());//blue System.out.println(person.getName());//zhang System.out.println(person1.getName());//liu } } class Person implements Cloneable{ private String name; private Car car; public Person(String name,Car car) { this.car = car; this.name = name; } public Object clone() throws CloneNotSupportedException { // TODO Auto-generated method stub Person person = (Person)super.clone(); person.car = (Car)car.clone(); return person; } public void setName(String name) { this.name = name; } public void setCar(Car car) { this.car = car; } public String getName() { return name; } public Car getCar() { return car; } } class Car implements Cloneable{ private String color; public Car(String color) { this.color = color; } public String getColor() { return color; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } public void setColor(String color) { this.color = color; } }

输出结果：

false
false
true
red
blue
zhang
liu

上述运行结果发生了改变，这次person和person.car的属性按照我们的预期都深拷贝过来了，现在思考一下，如果是Car类中还有其他pojo类的时候怎么办？我们难道只能层层实现clone()方法吗？那么接下来我们可以使用反序列化的方法来clone()一个方法。

反序列化

序列化机制提供了一种克隆对象的简便途径，只要对应的类是可序列化的就可以，做法是直接将对象序列化到输出流中，然后将其读回，这样产生的新的对象是对现有对象的一个深拷贝。在此过程中，我们不必将对象写到文件中，因为可以用ByteArrayOutputStream将数据保存到字节数组中。经过测试，已经完成深拷贝

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable; public class Test { public static void main(String[] args) throws Exception { Car car = new Car("red"); Person person = new Person("zhang",car, 0); Person person1 = (Person)person.deepClone(); System.out.println(person1); System.out.println(person.hashCode() == person1.hashCode());//false System.out.println(person.getCar().hashCode() == person1.getCar().hashCode());//false System.out.println(person.getName().hashCode() == person1.getName().hashCode());//true person1.getCar().setColor("blue"); person1.setName("liu"); person1.setAge(11); System.out.println(person.getCar().getColor());//red System.out.println(person1.getCar().getColor());//blue System.out.println(person.getName());//zhang System.out.println(person1.getName());//liu } } class Person implements Serializable{ private static final long serialVersionUID = 1L; private int age; private String name; private Car car; public Person(String name,Car car ,int age) { this.car = car; this.name = name; this.age = age; } public Object deepClone() throws Exception { //将对象写到流里 ByteArrayOutputStream 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()); } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void setName(String name) { this.name = name; } public void setCar(Car car) { this.car = car; } public String getName() { return name; } public Car getCar() { return car; } } class Car implements Serializable{ private static final long serialVersionUID = 1L; private String color; public Car(String color) { this.color = color; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } }

运行结果：

CloneTest.Person@60e7a94c
false
false
true
red
blue
zhang
liu

如有错误欢迎您指出来，谢谢