在Java开发中,理解对象的深拷贝 与浅拷贝是非常重要的。这两种拷贝方式决定了对象在内存中是如何被复制的,以及它们对原对象的引用与数据的影响。本文将详细介绍深拷贝与浅拷贝的概念、区别以及如何在Java中实现它们。
1. 浅拷贝(Shallow Copy)
浅拷贝 是指对象的字段 会被复制,但如果字段是对其他对象的引用,那么拷贝后的对象与原对象将共享这些引用。也就是说,对象中的所有引用类型字段并没有被真正复制,它们仍然指向同一个内存地址。
示例代码:
java
class Person implements Cloneable {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 默认实现的clone()方法为浅拷贝
}
}
public class ShallowCopyExample {
public static void main(String[] args) throws CloneNotSupportedException {
Person original = new Person("John", 25);
Person shallowCopy = (Person) original.clone();
System.out.println("Original name: " + original.name); // John
System.out.println("Shallow copy name: " + shallowCopy.name); // John
shallowCopy.name = "Doe";
System.out.println("After modification:");
System.out.println("Original name: " + original.name); // John
System.out.println("Shallow copy name: " + shallowCopy.name); // Doe
}
}
解释:
在上述代码中,Person
类实现了Cloneable
接口,并重写了clone()
方法。浅拷贝后的对象shallowCopy
中的name
字段与原始对象中的name
字段指向的是同一内存地址。因此,修改shallowCopy
中的name
会影响原对象中的name
字段。
注意:
- 基本数据类型:浅拷贝时,基本数据类型字段会被直接复制,拷贝对象和原对象的值是独立的。
- 引用类型:引用类型字段在浅拷贝时不会创建新对象,原对象与拷贝对象共用同一个引用对象。
2. 深拷贝(Deep Copy)
深拷贝 与浅拷贝的不同之处在于:深拷贝不仅复制对象本身,还会递归地复制 对象所引用的其他对象。也就是说,深拷贝会创建一个独立的对象副本,拷贝后的对象和原对象不会共享内存中的引用。
示例代码:
java
class Address implements Cloneable {
String city;
public Address(String city) {
this.city = city;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Person implements Cloneable {
String name;
int age;
Address address;
public Person(String name, int age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Person cloned = (Person) super.clone();
cloned.address = (Address) address.clone(); // 递归拷贝引用类型
return cloned;
}
}
public class DeepCopyExample {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address("New York");
Person original = new Person("John", 25, address);
Person deepCopy = (Person) original.clone();
System.out.println("Original city: " + original.address.city); // New York
System.out.println("Deep copy city: " + deepCopy.address.city); // New York
deepCopy.address.city = "Los Angeles";
System.out.println("After modification:");
System.out.println("Original city: " + original.address.city); // New York
System.out.println("Deep copy city: " + deepCopy.address.city); // Los Angeles
}
}
解释:
在这个例子中,Person
对象包含一个引用类型的Address
对象。为了实现深拷贝,Person
的clone()
方法不仅调用了super.clone()
,还调用了Address
的clone()
方法。这样确保了Person
对象的所有引用类型字段都被独立复制。
深拷贝的方式:
- 递归调用
clone()
:如上例所示,递归地调用所有引用对象的clone()
方法,实现对复杂对象的完全复制。 - 序列化与反序列化:另一种常用的深拷贝方法是通过Java的序列化机制,将对象序列化为字节流,再反序列化为新对象。这种方式可以确保对象的完整复制。
通过序列化实现深拷贝:
java
import java.io.*;
class Address implements Serializable {
String city;
public Address(String city) {
this.city = city;
}
}
class Person implements Serializable {
String name;
int age;
Address address;
public Person(String name, int age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
}
public class DeepCopyWithSerialization {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Address address = new Address("New York");
Person original = new Person("John", 25, address);
// 序列化对象
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(original);
// 反序列化对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
Person deepCopy = (Person) ois.readObject();
System.out.println("Original city: " + original.address.city); // New York
System.out.println("Deep copy city: " + deepCopy.address.city); // New York
deepCopy.address.city = "Los Angeles";
System.out.println("After modification:");
System.out.println("Original city: " + original.address.city); // New York
System.out.println("Deep copy city: " + deepCopy.address.city); // Los Angeles
}
}
解释:
通过Java序列化机制,我们可以将对象完全拷贝为独立的对象实例。序列化将对象转化为字节流,反序列化会生成一个新的对象副本,从而实现深拷贝。
3. 深拷贝与浅拷贝的比较
特性 | 浅拷贝 | 深拷贝 |
---|---|---|
拷贝方式 | 只拷贝对象本身和基本类型字段 | 拷贝对象本身及其所有引用对象 |
引用共享 | 原对象和拷贝对象共享引用类型字段的引用地址 | 原对象和拷贝对象完全独立 |
实现复杂度 | 较简单,默认实现的clone() 方法即为浅拷贝 |
较复杂,需要递归实现或使用序列化方式 |
应用场景 | 适用于对象引用的共享不会带来问题的场景 | 适用于需要深层次复制复杂对象的场景 |
4. 总结
- 浅拷贝:仅复制对象本身,不复制其引用类型字段,导致原对象与拷贝对象共享引用。
- 深拷贝:不仅复制对象本身,还会递归复制所有引用类型字段,实现完全独立的对象拷贝。
在实际开发中,选择浅拷贝还是深拷贝取决于对象的复杂度及引用的使用场景。如果需要确保对象和其引用对象的完全独立,则应使用深拷贝;而在不需要深层次对象复制的情况下,浅拷贝可以提高性能并减少内存开销。