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

第一个false表明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

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