[Java实战履历]对象拷贝
首先，对于不可变的类，我们不应该实现Cloneable接口，因为不可变类不需要拷贝，直接引用即可，实现Cloneable接口只会造成浪费。对于Java可变类来说，拷贝分为浅拷贝与深拷贝。
[*]浅拷贝（Shallow Copy）
只复制第一层，嵌套对象共享引用，适合简单场景。常见的Object.clone()方法就是浅拷贝。
[*]深拷贝（Deep Copy）
递归复制所有层，完全独立，适合复杂数据。一般需要手动实现或使用第三方依赖。
谨慎重写clone方法
Cloneable是一个标记接口（marker interface），没有方法声明。clone方法定义在Object类中，且是protected，需要子类显式重写为public。
Object.clone()默认实验浅拷贝，不实用于需要深拷贝的场景。如果重写clone()来支持深拷贝会怎么样呢？会不会有标题？
重写clone()支持深拷贝带来的标题
[*] 代码复杂，维护成本高
必须确保嵌套对象和对象的元素支持clone，需要递归处理所有字段。
嵌套多层时逐层克隆容易出错且难以维护、耦合高。
[*] 不可变字段
final字段无法在clone中赋值，限制使用场景。
[*] 异常处理复杂
需要处理CloneNotSupportedException 异常，必须try-catch。
// 需要捕获异常或抛出
try {
Person cloned = (Person) original.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
如果一个类实现了 Cloneable 接口，那么 Object 的 clone 方法将返回该对象的逐个属性（field-by-field）拷贝，属性中包含对象（嵌套对象）也需要实现Cloneable接口，否则会抛出 CloneNotSupportedException 异常。
因此，固然可以重写clone()来支持深拷贝，但是并不发起如许做。
合适的深拷贝
[*]手动递归+clone()方法
递归调用clone方法()，可以结合Stream API。如常见的List深拷贝，借助主流工具包Google Guava 的 Lists.newArrayList()然后clone()：
// 使用 Guava 和手动 clone
List<Person> deepCopy = Lists.newArrayList(
originalList.stream()
.map(p -> (Person) p.clone()) // 假设 Person 实现 Cloneable
.toList()
);
[*] 使用构造函数拷贝
《Effective Java》保举的方式。通过构造函数创建新对象，递归复制字段。
如许可以支持final字段，逻辑清楚，易于维护和扩展。但是需要为每个类编写拷贝逻辑。
[*] 使用序列化方式
通过序列化（如ObjectOutputStream）将对象转为字节省，再反序列化生成副本。
这种方式性能开销大，且需要对象类实现Serializable。
可以自己实现，也可以使用第三方的。
如Apache Commons Lang 的 SerializationUtils
import org.apache.commons.lang3.SerializationUtils;
// 使用 Apache Commons 的 SerializationUtils
List<Person> deepCopy = SerializationUtils.clone(originalList);
Jackson实现了不需要实现Serializable接口的方式，使用JSON序列化，性能较低
import com.fasterxml.jackson.databind.ObjectMapper;
ObjectMapper objectMapper = new ObjectMapper();
List<Person> deepCopy = objectMapper.readValue(
objectMapper.writeValueAsString(originalList),
new TypeReference<List<Person>>() {}
);
[*]简单场景：构造函数方式，代码简洁。
[*]高性能需求：手动实现 Cloneable 接口，控制深拷贝逻辑。
[*]复杂嵌套对象：序列化方法+第三方工具（如 SerializationUtils 或 Jackson），主动处理嵌套对象。
《Effective Java》一书中提到：
如果你继承一个已经实现了 Cloneable 接口的类，你别无选择，只能实现一个行为良好的 clone 方法。 否则，通常你最好提供另一种对象复制方法。 对象复制更好的方法是提供一个复制构造方法或复制工厂。
即，保举使用构造方法大概复制工厂。
// Copy constructor
public Yum(Yum yum){...};
// Copy factory
public static Yum newInstance(Yum yum){...};
这两种方式更为灵活、不受接口实现、范例、final的限制。
另外附一段构造函数+序列化例子
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
// 嵌套对象类
class InnerObject implements Serializable {
private int value;
public InnerObject(int value) {
this.value = value;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
// 拷贝构造函数
public InnerObject(InnerObject other) {
this.value = other.value;
}
}
// 外层对象类
class OuterObject implements Serializable {
private int number;
private InnerObject inner;
private List<Integer> numbers;
public OuterObject(int number, InnerObject inner, List<Integer> numbers) {
this.number = number;
this.inner = inner;
this.numbers = numbers;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public InnerObject getInner() {
return inner;
}
public List<Integer> getNumbers() {
return numbers;
}
// 拷贝构造函数（深拷贝）
public OuterObject(OuterObject other) {
this.number = other.number;
this.inner = new InnerObject(other.inner); // 深拷贝嵌套对象
this.numbers = new ArrayList<>(other.numbers); // 深拷贝集合
}
// 序列化实现深拷贝
public OuterObject deepCopyViaSerialization() {
try {
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (OuterObject) ois.readObject();
} catch (IOException | ClassNotFoundException e) {
throw new RuntimeException("Deep copy failed", e);
}
}
}
public class DeepCopyExample {
public static void main(String[] args) {
// 创建原始对象
InnerObject inner = new InnerObject(10);
List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3));
OuterObject original = new OuterObject(100, inner, numbers);
// 拷贝构造函数深拷贝
OuterObject copyConstructor = new OuterObject(original);
// 序列化深拷贝
OuterObject copySerialized = original.deepCopyViaSerialization();
// 修改副本
copyConstructor.setNumber(888);
copyConstructor.getInner().setValue(444);
copyConstructor.getNumbers().set(0, 999);
copySerialized.setNumber(777);
copySerialized.getInner().setValue(333);
copySerialized.getNumbers().set(0, 666);
// 输出结果
System.out.println("原始对象: number=" + original.getNumber() +
", inner.value=" + original.getInner().getValue() +
", numbers=" + original.getNumbers());
System.out.println("拷贝构造: number=" + copyConstructor.getNumber() +
", inner.value=" + copyConstructor.getInner().getValue() +
", numbers=" + copyConstructor.getNumbers());
System.out.println("序列化拷贝: number=" + copySerialized.getNumber() +
", inner.value=" + copySerialized.getInner().getValue() +
", numbers=" + copySerialized.getNumbers());
}
}
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]