Java对象拷贝的浅与深：如何选择？

在日常开发中，我们经常需要将一个对象的属性复制到另一个对象中。无论是使用第三方工具类还是自己手动实现，都会涉及到浅拷贝和深拷贝的问题。本文将深入讨论浅拷贝的潜在风险，并给出几种实现深拷贝的方式，帮助大家避免潜在的坑。

一、什么是浅拷贝？

在Java中，浅拷贝只会复制对象的基本类型字段，而对引用类型字段只复制引用的内存地址，不会递归复制引用的对象。这意味着，多个对象共享同一个引用，修改其中一个对象的引用字段可能会影响其他对象。

示例：Hutool和Apache Common工具类的浅拷贝

在项目中我们常使用工具类如 Hutool 的 BeanUtil.copyProperties() 或 Apache Commons 的 BeanUtils.copyProperties() 来进行对象的拷贝。这些工具类默认情况下都执行浅拷贝。

本篇以Hutool的举例，依赖如下

      <dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.3.1</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency>

import cn.hutool.core.bean.BeanUtil;@AllArgsConstructor
@NoArgsConstructor
@Builder
@Data
class User {private Long userId;private String name;private String email;public static void main(String[] args) {User oldUser = new User(1L, "lps", "email");User newUser = new User();// 使用 Hutool 工具类拷贝属性BeanUtil.copyProperties(oldUser, newUser);// 修改原对象的 userIdoldUser.setUserId(2L);// 输出新对象的属性System.out.println(newUser); // 结果：User(userId=1, name=lps, email=email)}
}

这个例子中的 Hutool 工具类对 oldUser 进行了浅拷贝。修改 oldUser 的 userId 并不会影响 newUser，因为 Long 是不可变类型。但如果 User 类中包含引用类型（例如 List、自定义对象），浅拷贝就会带来问题。

二、浅拷贝的潜在问题

浅拷贝最大的风险在于引用类型数据的共享。当你修改一个对象中的引用字段时，拷贝出来的对象也会随之改变。

示例：浅拷贝带来的问题

@AllArgsConstructor
@NoArgsConstructor
@Builder
@Data
class Address {private String city;
}@AllArgsConstructor
@NoArgsConstructor
@Builder
@Data
class User {private Long userId;private String name;private String email;private Address address;public static void main(String[] args) {Address address = new Address("Beijing");User oldUser = new User(1L, "lps", "email", address);User newUser = new User();// 浅拷贝 oldUser 到 newUserBeanUtil.copyProperties(oldUser, newUser);// 修改 oldUser 的地址oldUser.getAddress().setCity("Shanghai");// 输出新对象的地址System.out.println(newUser.getAddress().getCity()); // 结果："Shanghai"}
}

在这个例子中，修改了 oldUser 的 address 对象，导致 newUser 的 address 也被改变。这就是浅拷贝的典型问题。

三、深拷贝：如何避免共享引用的问题？

为了避免浅拷贝带来的问题，深拷贝通过递归地复制所有引用对象来确保两个对象完全独立。实现深拷贝有多种方式，下面介绍几种常见的做法。

1. 手动实现深拷贝

最常见的方法是手动在 clone() 方法中递归调用所有引用对象的 clone() 方法。

@AllArgsConstructor
@NoArgsConstructor
@Builder
@Data
class Address implements Cloneable {private String city;@Overrideprotected Address clone() {try {return (Address) super.clone();} catch (CloneNotSupportedException e) {throw new AssertionError(); }}
}@AllArgsConstructor
@NoArgsConstructor
@Builder
@Data
class User implements Cloneable {private Long userId;private String name;private String email;private Address address;@Overrideprotected User clone() {try {User cloned = (User) super.clone();cloned.setAddress(this.address.clone());  // 手动深拷贝return cloned;} catch (CloneNotSupportedException e) {throw new AssertionError();}}
}

手动实现深拷贝虽然可以控制每个引用的拷贝逻辑，但对于复杂对象来说，编写和维护都比较繁琐。

2. 使用序列化实现深拷贝

序列化是另一种常见的深拷贝方法，它通过将对象序列化为字节流，再反序列化为新的对象来实现深拷贝。

public User deepCopy() {try {ByteArrayOutputStream byteOut = new ByteArrayOutputStream();ObjectOutputStream out = new ObjectOutputStream(byteOut);out.writeObject(this);ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());ObjectInputStream in = new ObjectInputStream(byteIn);return (User) in.readObject();} catch (IOException | ClassNotFoundException e) {throw new RuntimeException("深拷贝失败", e);}
}

虽然序列化方法较为简单通用，但它要求所有参与拷贝的类都实现 Serializable 接口，并且序列化和反序列化的性能开销较大。