1. 说明

Java对象复制可分为浅拷贝（shallow copy）和深度拷贝（deep copy）两种。浅拷贝指从源对象中将值复制出来，因此产生的拷贝对象与源对象并不是独立的。如源对象存在引用属性（reference），此时的拷贝对象和源对象的相同引用属性都指向同一个对象，修改引用属性对象的内容，对于拷贝对象和源对象都可见。深度拷贝指将源对象的对象图中所有对象都被拷贝一次，因此产生的拷贝对象与源对象是独立的。即引用属性的拷贝，也是将引用指向的对象拷贝一份。源对象的对象图中任何属性的改变，并不会影响拷贝对象的属性。

理解上面的含义后，我们下面将比较两种拷贝方式，并讨论4种深度拷贝的实现。

2. 准备

2.1 依赖

我们将使用Maven来管理项目依赖，需要引入Gson，JackSon，Apache Commons Lang。

<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.8.5</version>
</dependency>
<dependency>
  <groupId>commons-lang</groupId>
  <artifactId>commons-lang</artifactId>
  <version>2.6</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.6</version>
</dependency>

最新的Gson、JackSon、Apache Commons Lang的版本可以在Maven Central仓库查看。

2.2 模型

我们需要引入2个对象类，来比较两种拷贝方式。

class Address {
    private String street;
    private String city;
    private String country;

    // standard constructors, getters and setters
}

class User {
    private String name;
    private Address address;
 
    // standard constructors, getters and setters
}

3. 浅拷贝

浅拷贝仅从源对象中复制属性的值，如果是引用属性，也只是复制引用的地址值。

import static org.hamcrest.core.IsNot.not;
import static org.hamcrest.core.IsSame.sameInstance;
import static org.junit.Assert.assertThat;

import org.junit.Test;

@Test
public void shouldNotBeSame_WhenShallowCopy() {
    Address address = new Address("西湖区丰潭路380号", "杭州", "中国");
    User origin = new User("嗨皮的孩子", address);
    User shallowCopy = new User(origin.getName(), origin.getAddress());
    assertThat(shallowCopy, not(sameInstance(origin)));
}

在这种情况下origin != shallowCopy，也就是说前拷贝的对象与源对象是不同的。

import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertThat;

import org.junit.Test;

@Test
public void shouldCopyChange_whenModifyingOriginalObject() {
    Address address = new Address("西湖区丰潭路380号", "杭州", "中国");
    User origin = new User("嗨皮的孩子", address);
    User shallowCopy = new User(origin.getName(), origin.getAddress());
    address.setStreet("西湖区丰潭路381号");
    assertThat(shallowCopy.getAddress().getStreet(),equalTo(origin.getAddress().getStreet()));
}

在上面的测试中，我们改变源对象的地址属性中的street的值时，拷贝对象的地址属性中的street属性也跟着变化。

4. 深度拷贝

如果我们希望地址对象是不可变（immutable），我们要解决的方法是要在对象树中递归的拷贝每一个可变的对象。下面将讨论不同的方式来实现深度拷贝。

4.1 构造函数

基于复制构造函数实现深度拷贝。

public Address(Address that) {
    this(that.getStreet(), that.getCity(), that.getCountry());
}


public User(User that) {
    this(that.getName(), new Address(that.getAddress()));
}

import static org.junit.Assert.assertNotEquals;

import org.junit.Test;

@Test
public void shouldNotChange_WhenModifyingOriginalObject() {
    Address address = new Address("西湖区丰潭路380号", "杭州", "中国");
    User origin = new User("嗨皮的孩子", address);
    User shallowCopy = new User(origin);
    address.setStreet("西湖区丰潭路381号");
    assertNotEquals(shallowCopy.getAddress().getStreet(), origin.getAddress().getStreet());
}

基于构造函数实现的深度对象拷贝方法解决“拷贝对象”和“源对象”独立性问题。上述中，我们没有新建String对象，原因String是不可变对象类。

4.2 Cloneable 接口

基于Object#clone方法实现对象复制，但是Object#clone是protected方法，在覆写时，需要改成public修饰。我们需要在类的定义中实现Cloneable接口，标记对象是可以clone。

覆写Address类的clone方法

class Address implements Cloneable {
    private String street;
    private String city;
    private String country;
    // standard constructors, getters and setters

    ... ...
    
    @Override public Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return new Address(this.street, this.getCity(), this.getCountry());
        }
    }
}

覆写User类的clone方法

class User implements Cloneable {
    private String name;
    private Address address;

    //standard constructors, getters and setters

    ... ...
    
    @Override public Object clone() {
        User user;
        try {
            user = (User) super.clone();
        } catch (CloneNotSupportedException e) {
            user = new User(this.getName(), this.getAddress());
        }
        user.address = (Address) this.address.clone();
        return user;
    }
}

import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertThat;

import org.junit.Test;

@Test
public void shouldNotChange_WhenModifyingOriginalObjectUsingCloneCopy() {
    Address address = new Address("西湖区丰潭路380号", "杭州", "中国");
    User origin = new User("嗨皮的孩子", address);
    User shallowCopy = (User) origin.clone();
    address.setStreet("西湖区丰潭路381号");
    assertThat(shallowCopy.getAddress().getStreet(), not(equalTo(origin.getAddress().getStreet())));
}

super.clone方法实现的是浅拷贝，因此返回的为浅拷贝对象。我们需要对于可变对象的属性，重新设置新的值。

4.3 借助第三方库

前面提到2种深度拷贝方式很直观。但是当你不能添加额外的构造函数或者复写clone方法时，就需要借助第三方库实现深度拷贝。

核心的思想是“我们先系列化对象，然后再反系列化为新的对象”。

4.3.1 Apache Commons Lang

Apache Commons Lang有SerializationUtils#clone方法，使用该方法可以深度复制出对象图中所有实现Serializable接口对象。此方法要求对象图中的类都实现Serializable接口，否则会抛出SerializationException。

class Address implements Serializable, Cloneable {
    private String street;
    private String city;
    private String country;
    // standard constructors, getters and setters

    ... ...
    
    @Override public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return new Address(this.street, this.getCity(), this.getCountry());
        }
    }
}

class User implements Serializable, Cloneable {
    private String name;
    private Address address;

    //standard constructors, getters and setters

    ... ...
    
    @Override public Object clone() {
        User user;
        try {
            user = (User) super.clone();
        } catch (CloneNotSupportedException e) {
            user = new User(this.getName(), this.getAddress());
        }
        user.address = (Address) this.address.clone();
        return user;
    }
}

import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertThat;

import org.apache.commons.lang.SerializationUtils;
import org.junit.Test;

@Test
public void shouldNotChange_WhenModifyingOriginalObjectUsingCommonsClone() {
    Address address = new Address("西湖区丰潭路380号", "杭州", "中国");
    User origin = new User("嗨皮的孩子", address);
    User shallowCopy = (User) SerializationUtils.clone(origin);
    address.setStreet("西湖区丰潭路381号");
    assertThat(shallowCopy.getAddress().getStreet(), not(equalTo(origin.getAddress().getStreet())));
}

4.3.2 使用Gson的JSON系列化

使用Json系列化方式，也可以的达到深度复制，Gson库可以用来将对象转为JSON，或从JSON转为对象。Gson不要求类实现Serializable接口。

class Address implements Serializable, Cloneable {
    private String street;
    private String city;
    private String country;

    public Address(String street, String city, String country) {
        this.street = street;
        this.city = city;
        this.country = country;
    }

    public Address(Address that) {
        this(that.getStreet(), that.getCity(), that.getCountry());
    }

    @Override public Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return new Address(this.street, this.getCity(), this.getCountry());
        }
    }
    ... ...
    //getters and setters
}


class User implements Serializable, Cloneable {
    private String name;
    private Address address;

    public User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    public User(User that) {
        this(that.getName(), new Address(that.getAddress()));
    }

    @Override public Object clone() {
        User user;
        try {
            user = (User) super.clone();
        } catch (CloneNotSupportedException e) {
            user = new User(this.getName(), this.getAddress());
        }
        user.address = (Address) this.address.clone();
        return user;
    }
    ... ...
    //getters and setters
}

import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertThat;

import com.google.gson.Gson;
import org.junit.Test;

@Test
public void shouldNotChange_WhenModifyingOriginalObjectUsingGsonClone() {
    Address address = new Address("西湖区丰潭路380号", "杭州", "中国");
    User origin = new User("嗨皮的孩子", address);
    Gson gson = new Gson();
    User shallowCopy = gson.fromJson(gson.toJson(origin), User.class);
    address.setStreet("西湖区丰潭路381号");
    assertThat(shallowCopy.getAddress().getStreet(), not(equalTo(origin.getAddress().getStreet())));
}

4.3.3 使用Jackson的JSON系列化

Jackson是另一个JSON系列化库，实现上类似于Gson，但是我们需要给类提供默认构造函数。

class Address implements Serializable, Cloneable {
    private String street;
    private String city;
    private String country;

    public Address() {}

    public Address(String street, String city, String country) {
        this.street = street;
        this.city = city;
        this.country = country;
    }

    public Address(Address that) {
        this(that.getStreet(), that.getCity(), that.getCountry());
    }

    @Override public Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return new Address(this.street, this.getCity(), this.getCountry());
        }
    }
    ... ...
    //getters and setters
}


class User implements Serializable, Cloneable {
    private String name;
    private Address address;

    public User() {}

    public User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    public User(User that) {
        this(that.getName(), new Address(that.getAddress()));
    }

    @Override public Object clone() {
        User user;
        try {
            user = (User) super.clone();
        } catch (CloneNotSupportedException e) {
            user = new User(this.getName(), this.getAddress());
        }
        user.address = (Address) this.address.clone();
        return user;
    }
    ... ...
    //getters and setters
}

import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertThat;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;

import java.io.IOException;

@Test
public void shouldNotChange_WhenModifyingOriginalObjectUsingJacksonClone() throws IOException {
    Address address = new Address("西湖区丰潭路380号", "杭州", "中国");
    User origin = new User("嗨皮的孩子", address);
    ObjectMapper objectMapper = new ObjectMapper();
    User shallowCopy = objectMapper.readValue(objectMapper.writeValueAsString(origin), User.class);
    address.setStreet("西湖区丰潭路381号");
    assertThat(shallowCopy.getAddress().getStreet(), not(equalTo(origin.getAddress().getStreet())));
}

5. 总结

当我们需要深度复制对象时，该选择哪一种实现方式呢？依赖于我们需要复制的类，并且是否我们在对象图中拥有这些类。本文来自于java-deep-copy的翻译。

[1] : http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22com.google.code.gson%22%20AND%20a%3A%22gson%22 "Gson"
[2] : http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22com.fasterxml.jackson.core%22%20AND%20a%3A%22jackson-databind%22 "JackSon"
[3] : http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22commons-lang%22%20AND%20a%3A%22commons-lang%22 "Apache Commons Lang"
[4] : http://www.baeldung.com/java-deep-copy "java-deep-copy"