Java实现对象深度拷贝的四种主流方法-开发者社区-阿里云

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的版本可以在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. 总结

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

[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"

Java对象的深度拷贝实现

1. 说明

2. 准备

2.1 依赖

2.2 模型

3. 浅拷贝

4. 深度拷贝

4.1 构造函数

4.2 Cloneable 接口

4.3 借助第三方库

4.3.1 Apache Commons Lang

4.3.2 使用Gson的JSON系列化

4.3.3 使用Jackson的JSON系列化

5. 总结

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Java对象的深度拷贝实现

1. 说明

2. 准备

2.1 依赖

2.2 模型

3. 浅拷贝

4. 深度拷贝

4.1 构造函数

4.2 Cloneable 接口

4.3 借助第三方库

4.3.1 Apache Commons Lang

4.3.2 使用Gson的JSON系列化

4.3.3 使用Jackson的JSON系列化

5. 总结

热门文章

最新文章

相关课程

相关电子书