深复制和浅复制也称为深拷贝和浅拷贝。简单的说就是创建一个和当前对象一模一样的对象。在日常编码的过程中使用的几率并不多，但在面试中却会被经常问到。
了解深复制和浅复制的原理后，可以帮助我们对Java中的值传递和引用传递有更深刻的理解。
浅复制
下面的实例中，我们创建一个原始类Monster，调用对象的clone方法复制一个新的对象。
注意：要调用对象的clone方法，需要让类实现Cloneable接口，并重写clone方法
public class Monster implements Cloneable{
private String name; //怪物名称
private int level; //怪物级别
private Point position; //怪物坐标
public Monster(String name, int level){
this.name = name;
this.level = level;
position = new Point(100, 100);
}
@Override
protected Object clone() throws CloneNotSupportedException {
//Cloneable接口仅仅是一个标志，而且这个标志也仅仅是针对 Object类中 clone()方法的，
//如果 clone类没有实现 Cloneable接口，并调用了 Object的 clone()方法
//（即调用super.clone()方法），那么Object的 clone()方法就会抛出
CloneNotSupportedException异常。
return super.clone();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public Point getPosition() {
return position;
}
public void setPosition(int x, int y) {
position.setX(x);
position.setY(y);
}
}
class Point{//坐标类
private int x;
private int y;
public Point(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;
}
}
public class MonsterTest {
public static void main(String[] args) throws
CloneNotSupportedException {
Monster monster1 = new Monster("史莱克", 99);
//通过clone方法，将对象monster1中的值复制到对象monster2
Monster monster2 = (Monster)monster1.clone();
//1.monster1和monster2是两个对象,下面的结果是false
System.out.println(monster1.equals(monster2));
//2.对比对象中的值（浅复制中，只复制了对象的引用）
System.out.println(monster1.getName() == monster2.getName());
System.out.println(monster1.getName().hashCode());
System.out.println(monster2.getName().hashCode());
//巩固第二点，修改monster2的坐标值
monster2.setPosition(111, 111);
//monster2的坐标值修改后，对象monster1的坐标值也被修改了
System.out.println(monster1.getPosition().getX() + "\t" + monster1.getPosition().getY());
}
}
我们可以通过这个例子体会浅复制的特点：
被复制对象的所有成员属性都有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
即浅复制后，新对象的地址变了，但新对象中字段（属性）所指向的内存地址（引用）却没变，新旧对象的字段指向了同一块内存空间。
深复制
深复制则是指在clone对象本身，也clone对象中中的属性（字段）
我们可以通过下面的代码体会：
public class Monster implements Cloneable{
private String name;
private int level;
private Point position;
public Monster(String name, int level){
this.name = name;
this.level = level;
position = new Point(100, 100);
}
@Override
protected Object clone() throws CloneNotSupportedException {
Monster monster = (Monster)super.clone();
//对象属性也通过clone方法复制-深复制
monster.position = (Point)position.clone();
return monster;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public Point getPosition() {
return position;
}
public void setPosition(int x, int y) {
position.setX(x);
position.setY(y);
}
}
class Point implements Cloneable{
private int x;
private int y;
public Point(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
protected Object clone() throws CloneNotSupportedException {
//作为属性类同样实现clone方法，就实现了深复制
return super.clone();
}
}
public class MonsterTest {
public static void main(String[] args) throws
CloneNotSupportedException {
Monster monster1 = new Monster("史莱克", 99);
//通过clone方法，将对象monster1中的值复制到对象monster2
Monster monster2 = (Monster)monster1.clone();
//1.monster1和monster2是两个对象,下面的结果是false - 同浅复制
System.out.println(monster1.equals(monster2));
//2.对比对象中的值（浅复制中，只复制了对象的引用） - 浅复制
System.out.println(monster1.getName() == monster2.getName());
System.out.println(monster1.getName().hashCode());
System.out.println(monster2.getName().hashCode());
//修改monster2的坐标值
monster2.setPosition(111, 111);
//深复制后，monster2的坐标值修改，对象monster1的坐标值并没有被修改
System.out.println(monster1.getPosition().getX() + "\t" + monster1.getPosition().getY());
}
}
上面的代码虽然实现了深复制，但是有个瑕疵，就是如果Monster类中出现自定义的引用类型属性（字段），这个引用类型就需要实现Cloneable接口并重写clone方法。引用类型多的情况下，会增加代码量。
实现深复制的另一种方法就是使用序列化技术：
序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。
注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。
import
java.io.ByteArrayInputStream;
import
java.io.ByteArrayOutputStream;
import
java.io.ObjectInputStream;
import
java.io.ObjectOutputStream;
import
java.io.Serializable;
public class Monster implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int level;
private Point position;
public Monster(String name, int level){
this.name = name;
this.level = level;
position = new Point(100, 100);
}
//深复制
public Object deepClone() throws Exception{
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public Point getPosition() {
return position;
}
public void setPosition(int x, int y) {
position.setX(x);
position.setY(y);
}
}
class Point implements Serializable{
private static final long serialVersionUID = 1L;
private int x;
private int y;
public Point(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;
}
}
public class MonsterTest {
public static void main(String[] args) throws Exception {
Monster monster1 = new Monster("史莱克", 99);
//调用自定义的deepClone方法（深复制），将对象monster1中的值复制到对象monster2
Monster monster2 = (Monster)monster1.deepClone();
//1.monster1和monster2是两个对象,下面的结果是false
System.out.println(monster1.equals(monster2));
//2.对比对象中的值
System.out.println(monster1.getName() == monster2.getName());
System.out.println(monster1.getName().hashCode());
System.out.println(monster2.getName().hashCode());
//修改monster2的坐标值
monster2.setPosition(111, 111);
//深复制后，monster2的坐标值修改，对象monster1的坐标值并没有被修改
System.out.println(monster1.getPosition().getX() + "\t" + monster1.getPosition().getY());
}
}
更多干货笔记关注微信公众号 : 老九学堂
原文地址：https://www.cnblogs.com/ljxt/p/11613020.html