深拷贝是指创建一个新对象，其内容与原对象相同但内存独立，修改互不影响。1.使用构造函数或工厂方法：适用于简单类且字段不可变时，通过拷贝构造函数创建新对象；2.使用clone()方法：需实现cloneable接口并重写clone()，对可变字段单独深拷贝；3.使用序列化和反序列化：通用但性能较差，要求类实现serializable接口；4.使用第三方库：如apache commons lang的serializationutils.clone()，基于序列化实现但需引入依赖。浅拷贝仅复制引用，修改会相互影响，而深拷贝确保对象完全独立。选择方法时应考虑类结构复杂度、性能需求及是否需要处理循环引用等场景。
深拷贝，简单来说，就是创建一个新对象，这个新对象拥有与原对象完全相同的内容，但它们在内存中是完全独立的。修改新对象不会影响原对象，反之亦然。
解决方案
在Java中实现对象的深拷贝，主要有以下几种方法：
立即学习“Java免费学习笔记（深入）”；
-
使用构造函数或工厂方法：
如果你的类足够简单，并且所有字段都是不可变的（immutable），那么直接使用拷贝构造函数或工厂方法是最简单高效的方法。例如：
public class Address { private String street; private String city; public Address(String street, String city) { this.street = street; this.city = city; } // 拷贝构造函数 public Address(Address other) { this.street = other.street; this.city = other.city; } // Getters and setters (省略) } public class Person { private String name; private int age; private Address address; public Person(String name, int age, Address address) { this.name = name; this.age = age; this.address = address; } // 拷贝构造函数 public Person(Person other) { this.name = other.name; this.age = other.age; // 深拷贝 Address 对象 this.address = new Address(other.address); } // Getters and setters (省略) } // 使用示例 Address originalAddress = new Address("123 Main St", "Anytown"); Person originalPerson = new Person("Alice", 30, originalAddress); Person copiedPerson = new Person(originalPerson); // 深拷贝 // 修改 copiedPerson 的 address 不会影响 originalPerson copiedPerson.getAddress().setStreet("456 Oak Ave"); System.out.println(originalPerson.getAddress().getStreet()); // 输出: 123 Main St System.out.println(copiedPerson.getAddress().getStreet()); // 输出: 456 Oak Ave关键在于，对于可变对象（如
Address），需要调用其拷贝构造函数或类似方法来创建新的对象实例，而不是简单地复制引用。 如果Address没有拷贝构造函数，而只是简单this.address = other.address;那就变成浅拷贝了。 -
使用
clone()方法：Java的
Object类提供了一个clone()方法，但是默认情况下，它执行的是浅拷贝。 要实现深拷贝，你需要：- 实现
Cloneable接口。 - 重写
clone()方法。 - 在
clone()方法中，对所有可变字段进行深拷贝。
public class Address implements Cloneable { private String street; private String city; public Address(String street, String city) { this.street = street; this.city = city; } // Getters and setters (省略) @Override public Address clone() { try { return (Address) super.clone(); // 浅拷贝 } catch (CloneNotSupportedException e) { throw new AssertionError(); // 不可能发生，因为实现了 Cloneable } } } public class Person implements Cloneable { private String name; private int age; private Address address; public Person(String name, int age, Address address) { this.name = name; this.age = age; } // Getters and setters (省略) @Override public Person clone() { try { Person cloned = (Person) super.clone(); // 浅拷贝 cloned.address = this.address.clone(); // 深拷贝 Address return cloned; } catch (CloneNotSupportedException e) { throw new AssertionError(); } } } // 使用示例 Address originalAddress = new Address("123 Main St", "Anytown"); Person originalPerson = new Person("Alice", 30, originalAddress); Person copiedPerson = originalPerson.clone(); // 深拷贝 // 修改 copiedPerson 的 address 不会影响 originalPerson copiedPerson.getAddress().setStreet("456 Oak Ave"); System.out.println(originalPerson.getAddress().getStreet()); System.out.println(copiedPerson.getAddress().getStreet());需要注意的是，
clone()方法的实现可能会比较繁琐，尤其是当类结构比较复杂时。 而且clone()方法容易出错，需要处理CloneNotSupportedException， 并且需要强制类型转换。 - 实现
-
使用序列化和反序列化：
这是一种通用的深拷贝方法，它将对象序列化成字节流，然后再反序列化成新的对象。 这种方法简单粗暴，但性能相对较差，并且要求所有需要深拷贝的类都必须实现
Serializable接口。import java.io.*; public class Address implements Serializable { private String street; private String city; public Address(String street, String city) { this.street = street; this.city = city; } // Getters and setters (省略) } public class Person implements Serializable { private String name; private int age; private Address address; public Person(String name, int age, Address address) { this.name = name; this.age = age; } // Getters and setters (省略) } public class DeepCopy { public staticT deepCopy(T obj) { try { ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(obj); ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return (T) ois.readObject(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); return null; } } } // 使用示例 Address originalAddress = new Address("123 Main St", "Anytown"); Person originalPerson = new Person("Alice", 30, originalAddress); Person copiedPerson = DeepCopy.deepCopy(originalPerson); // 深拷贝 // 修改 copiedPerson 的 address 不会影响 originalPerson copiedPerson.getAddress().setStreet("456 Oak Ave"); System.out.println(originalPerson.getAddress().getStreet()); System.out.println(copiedPerson.getAddress().getStreet()); 这种方法的优点是简单，不需要修改原始类的代码（只需要实现
Serializable），缺点是性能较差，并且如果对象中包含不可序列化的字段，会抛出异常。 -
使用第三方库：
一些第三方库，如 Apache Commons Lang，提供了深拷贝的工具类。 例如：
import org.apache.commons.lang3.SerializationUtils; public class Address implements Serializable { private String street; private String city; public Address(String street, String city) { this.street = street; this.city = city; } // Getters and setters (省略) } public class Person implements Serializable { private String name; private int age; private Address address; public Person(String name, int age, Address address) { this.name = name; this.age = age; } // Getters and setters (省略) } // 使用示例 Address originalAddress = new Address("123 Main St", "Anytown"); Person originalPerson = new Person("Alice", 30, originalAddress); Person copiedPerson = SerializationUtils.clone(originalPerson); // 深拷贝 // 修改 copiedPerson 的 address 不会影响 originalPerson copiedPerson.getAddress().setStreet("456 Oak Ave"); System.out.println(originalPerson.getAddress().getStreet()); System.out.println(copiedPerson.getAddress().getStreet());SerializationUtils.clone()实际上也是基于序列化和反序列化实现的。 使用第三方库可以简化代码，但需要引入额外的依赖。
浅拷贝和深拷贝的区别是什么？
浅拷贝只是复制对象的引用，而不是对象本身。这意味着原始对象和拷贝对象指向内存中的同一个对象。如果修改了拷贝对象，原始对象也会受到影响。深拷贝则会创建一个新的对象，并将原始对象的所有内容复制到新对象中。原始对象和拷贝对象是完全独立的。
如何选择合适的深拷贝方法？
选择哪种深拷贝方法取决于你的具体需求。
- 如果类很简单，并且所有字段都是不可变的，那么使用拷贝构造函数或工厂方法是最简单高效的方法。
- 如果需要深拷贝的类已经实现了
Serializable接口，那么可以使用序列化和反序列化。 - 如果不想修改原始类的代码，或者需要处理复杂的对象图，那么可以考虑使用第三方库。
- 如果对性能要求很高，并且可以接受一定的代码复杂性，那么可以考虑使用
clone()方法，但需要仔细实现。
深拷贝的性能问题
深拷贝通常比浅拷贝性能更差，因为它需要创建新的对象，并复制所有的数据。 特别是使用序列化反序列化的方式，性能会比较差。 因此，在选择深拷贝方法时，需要权衡性能和代码复杂性。 在某些情况下，如果只需要拷贝对象的部分字段，可以考虑只对这些字段进行深拷贝，以提高性能。
如何处理循环引用？
如果对象之间存在循环引用（例如，A 对象引用 B 对象，B 对象又引用 A 对象），那么使用序列化和反序列化进行深拷贝可能会导致无限循环。 为了解决这个问题，可以使用 IdentityHashMap 来跟踪已经拷贝过的对象，避免重复拷贝。 一些第三方库也提供了处理循环引用的机制。
