Java中的深复制和浅赋值

深复制和浅复制也称为深拷贝和浅拷贝。简单的说就是创建一个和当前对象一模一样的对象。在日常编码的过程中使用的几率并不多，但在面试中却会被经常问到。

了解深复制和浅复制的原理后，可以帮助我们对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());

}

}

更多干货笔记关注微信公众号 : 老九学堂