Java

介绍

在Java语言里,当需要拷贝一个对象时,有两种类型的拷贝:浅拷贝与深拷贝。浅拷贝只是拷贝了源对象的地址,所以源对象的值发生变化时,拷贝对象的值也会发生变化。而深拷贝则是拷贝了源对象的所有值,所以即使源对象的值发生变化时,拷贝对象的值也不会改变。如下图描述:
Java中对一个对象进行深拷贝 - 图1
了解了浅拷贝和深拷贝的区别之后,了解几种深拷贝的方法。

拷贝对象

首先,定义一下需要拷贝的简单对象。

  1. /**
  2. * 用户
  3. */
  4. public class User {
  5. private String name;
  6. private Address address;
  7. // constructors, getters and setters
  8. }
  9. /**
  10. * 地址
  11. */
  12. public class Address {
  13. private String city;
  14. private String country;
  15. // constructors, getters and setters
  16. }

如上述代码,定义了一个User用户类,包含name姓名,和address地址,其中address并不是字符串,而是另一个Address类,包含country国家和city城市。构造方法和成员变量的get()set()方法此处省略不写。接下来将详细描述如何深拷贝User对象。

方法一 构造函数

可以通过在调用构造函数进行深拷贝,形参如果是基本类型和字符串则直接赋值,如果是对象则重新new一个。

测试用例

  1. @Test
  2. public void constructorCopy() {
  3. Address address = new Address("杭州", "中国");
  4. User user = new User("大山", address);
  5. // 调用构造函数时进行深拷贝
  6. User copyUser = new User(user.getName(), new Address(address.getCity(), address.getCountry()));
  7. // 修改源对象的值
  8. user.getAddress().setCity("深圳");
  9. // 检查两个对象的值不同
  10. assertNotSame(user.getAddress().getCity(), copyUser.getAddress().getCity());
  11. }

方法二 重载clone()方法

Object父类有个clone()的拷贝方法,不过它是protected类型的,需要重写它并修改为public类型。除此之外,子类还需要实现Cloneable接口来告诉JVM这个类是可以拷贝的。

重写代码

修改一下User类,Address类,实现Cloneable接口,使其支持深拷贝。

  1. /**
  2. * 地址
  3. */
  4. public class Address implements Cloneable {
  5. private String city;
  6. private String country;
  7. // constructors, getters and setters
  8. @Override
  9. public Address clone() throws CloneNotSupportedException {
  10. return (Address) super.clone();
  11. }
  12. }
  13. /**
  14. * 用户
  15. */
  16. public class User implements Cloneable {
  17. private String name;
  18. private Address address;
  19. // constructors, getters and setters
  20. @Override
  21. public User clone() throws CloneNotSupportedException {
  22. User user = (User) super.clone();
  23. user.setAddress(this.address.clone());
  24. return user;
  25. }
  26. }

需要注意的是,super.clone()其实是浅拷贝,所以在重写User类的clone()方法时,address对象需要调用address.clone()重新赋值。

测试用例

  1. @Test
  2. public void cloneCopy() throws CloneNotSupportedException {
  3. Address address = new Address("杭州", "中国");
  4. User user = new User("大山", address);
  5. // 调用clone()方法进行深拷贝
  6. User copyUser = user.clone();
  7. // 修改源对象的值
  8. user.getAddress().setCity("深圳");
  9. // 检查两个对象的值不同
  10. assertNotSame(user.getAddress().getCity(), copyUser.getAddress().getCity());
  11. }

方法三 Apache Commons Lang序列化

Java提供了序列化的能力,可以先将源对象进行序列化,再反序列化生成拷贝对象。但是,使用序列化的前提是拷贝的类(包括其成员变量)需要实现Serializable接口。Apache Commons Lang包对Java序列化进行了封装,可以直接使用它。

重写代码

修改一下User类,Address类,实现Serializable接口,使其支持序列化。

  1. /**
  2. * 地址
  3. */
  4. public class Address implements Serializable {
  5. private String city;
  6. private String country;
  7. // constructors, getters and setters
  8. }
  9. /**
  10. * 用户
  11. */
  12. public class User implements Serializable {
  13. private String name;
  14. private Address address;
  15. // constructors, getters and setters
  16. }

测试用例

  1. @Test
  2. public void serializableCopy() {
  3. Address address = new Address("杭州", "中国");
  4. User user = new User("大山", address);
  5. // 使用Apache Commons Lang序列化进行深拷贝
  6. User copyUser = (User) SerializationUtils.clone(user);
  7. // 修改源对象的值
  8. user.getAddress().setCity("深圳");
  9. // 检查两个对象的值不同
  10. assertNotSame(user.getAddress().getCity(), copyUser.getAddress().getCity());
  11. }

方法四 Gson序列化

Gson可以将对象序列化成JSON,也可以将JSON反序列化成对象,所以可以用它进行深拷贝。

测试用例

  1. @Test
  2. public void gsonCopy() {
  3. Address address = new Address("杭州", "中国");
  4. User user = new User("大山", address);
  5. // 使用Gson序列化进行深拷贝
  6. Gson gson = new Gson();
  7. User copyUser = gson.fromJson(gson.toJson(user), User.class);
  8. // 修改源对象的值
  9. user.getAddress().setCity("深圳");
  10. // 检查两个对象的值不同
  11. assertNotSame(user.getAddress().getCity(), copyUser.getAddress().getCity());
  12. }

方法五 Jackson序列化

Jackson与Gson相似,可以将对象序列化成JSON,明显不同的地方是拷贝的类(包括其成员变量)需要有默认的无参构造函数。

重写代码

修改一下User类,Address类,实现默认的无参构造函数,使其支持Jackson。

  1. /**
  2. * 用户
  3. */
  4. public class User {
  5. private String name;
  6. private Address address;
  7. // constructors, getters and setters
  8. public User() {
  9. }
  10. }
  11. /**
  12. * 地址
  13. */
  14. public class Address {
  15. private String city;
  16. private String country;
  17. // constructors, getters and setters
  18. public Address() {
  19. }
  20. }

测试用例

  1. @Test
  2. public void jacksonCopy() throws IOException {
  3. Address address = new Address("杭州", "中国");
  4. User user = new User("大山", address);
  5. // 使用Jackson序列化进行深拷贝
  6. ObjectMapper objectMapper = new ObjectMapper();
  7. User copyUser = objectMapper.readValue(objectMapper.writeValueAsString(user), User.class);
  8. // 修改源对象的值
  9. user.getAddress().setCity("深圳");
  10. // 检查两个对象的值不同
  11. assertNotSame(user.getAddress().getCity(), copyUser.getAddress().getCity());
  12. }

总结

说了这么多深拷贝的实现方法,哪一种方法才是最好的呢?最简单的判断就是根据拷贝的类(包括其成员变量)是否提供了深拷贝的构造函数、是否实现了Cloneable接口、是否实现了Serializable接口、是否实现了默认的无参构造函数来进行选择。如果需要详细的考虑,则可以参考下面的表格:
Java中对一个对象进行深拷贝 - 图2