深拷贝与浅拷贝的关键区别在于是否复制对象内部的引用对象。1. 浅拷贝仅复制对象的非引用类型字段，引用类型字段则共享同一地址，修改一个对象的引用字段会影响其他对象；2. 深拷贝递归复制所有引用对象，生成完全独立的新对象，修改新对象不影响原对象。3. 实现深拷贝的方式包括手动递归复制、重写 clone() 方法、序列化与反序列化、使用第三方库等。4. 选择拷贝方式需根据场景决定：浅拷贝适用于引用对象不可变或需要共享的情况，深拷贝适用于需完全独立的场景。5. 实现深拷贝时需注意循环引用问题，可通过缓存已复制对象避免无限递归。6. 深拷贝性能开销较大，在高性能场景中应谨慎使用或采用优化策略。
深拷贝和浅拷贝，关键在于拷贝对象时，是否复制了对象内部的引用对象。浅拷贝只复制引用，深拷贝则会递归地复制所有引用对象，生成全新的独立对象。
深拷贝和浅拷贝的区别，本质上是对对象内部引用类型的处理方式不同。
浅拷贝的陷阱：共享的引用
浅拷贝，也叫影子拷贝，创建新对象时，只复制原始对象的非引用类型字段的值。对于引用类型字段，新对象只是复制了引用地址，这意味着新对象和原始对象共享同一个引用对象。修改其中一个对象的引用对象，另一个对象也会受到影响。例如：
立即学习“Java免费学习笔记（深入）”；
class Address { String city; public Address(String city) { this.city = city; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } } class Person { String name; Address address; public Person(String name, Address address) { this.name = name; this.address = address; } public String getName() { return name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } // 浅拷贝方法 public Person shallowcopy() { return new Person(this.name, this.address); } } public class Main { public static void main(String[] args) { Address address = new Address("Beijing"); Person person1 = new Person("Alice", address); Person person2 = person1.shallowCopy(); // 修改 person2 的地址 person2.getAddress().setCity("Shanghai"); System.out.println("Person1's city: " + person1.getAddress().getCity()); // 输出 Shanghai System.out.println("Person2's city: " + person2.getAddress().getCity()); // 输出 Shanghai } }
可以看到，修改person2的地址后，person1的地址也跟着改变了。这就是浅拷贝的副作用，多个对象共享同一个内部引用对象。
实现深拷贝的几种方式
深拷贝则会完全复制原始对象及其所有引用对象，生成一个全新的、完全独立的对象。修改新对象不会影响原始对象。实现深拷贝的方法有几种：
- 手动实现： 递归地复制每一个引用类型的字段。这是最直接但也是最繁琐的方式。
class Address implements Cloneable { String city; public Address(String city) { this.city = city; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } @Override public Address clone() { try { return (Address) super.clone(); } catch (CloneNotSupportedException e) { throw new AssertionError(); } } } class Person implements Cloneable { String name; Address address; public Person(String name, Address address) { this.name = name; this.address = address; } public String getName() { return name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } // 深拷贝方法 @Override public Person clone() { try { Person cloned = (Person) super.clone(); cloned.address = this.address.clone(); // 关键：复制 Address 对象 return cloned; } catch (CloneNotSupportedException e) { throw new AssertionError(); } } } public class Main { public static void main(String[] args) { Address address = new Address("Beijing"); Person person1 = new Person("Alice", address); Person person2 = person1.clone(); // 修改 person2 的地址 person2.getAddress().setCity("Shanghai"); System.out.println("Person1's city: " + person1.getAddress().getCity()); // 输出 Beijing System.out.println("Person2's city: " + person2.getAddress().getCity()); // 输出 Shanghai } }
-
使用 clone() 方法： 让类实现 Cloneable 接口，并重写 clone() 方法。但需要注意，clone() 方法默认是浅拷贝，需要手动实现深拷贝逻辑。上面的代码示例已经展示了如何使用clone()方法实现深拷贝。
-
序列化和反序列化： 将对象序列化成字节流，再反序列化成新的对象。这种方式可以实现完全的深拷贝，但性能相对较低。需要类实现 Serializable 接口。
import Java.io.*; class Address implements Serializable { String city; public Address(String city) { this.city = city; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } } class Person implements Serializable { String name; Address address; public Person(String name, Address address) { this.name = name; this.address = address; } public String getName() { return name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } // 深拷贝方法 (使用序列化) public Person deepCopy() { 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 (Person) ois.readObject(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); return null; } } } public class Main { public static void main(String[] args) { Address address = new Address("Beijing"); Person person1 = new Person("Alice", address); Person person2 = person1.deepCopy(); // 修改 person2 的地址 person2.getAddress().setCity("Shanghai"); System.out.println("Person1's city: " + person1.getAddress().getCity()); // 输出 Beijing System.out.println("Person2's city: " + person2.getAddress().getCity()); // 输出 Shanghai } }
- 使用第三方库： 如 apache Commons Lang 的 SerializationUtils 或 Jackson 等库，可以简化序列化和反序列化的过程。
何时使用深拷贝，何时使用浅拷贝？
选择深拷贝还是浅拷贝，取决于具体的应用场景和需求。
- 浅拷贝： 适用于对象内部的引用对象是不可变的（immutable），或者多个对象共享同一个引用对象是期望行为的场景。例如，字符串常量池中的字符串。
- 深拷贝： 适用于需要创建完全独立的副本，避免修改一个对象影响到其他对象的场景。例如，在多线程环境下，需要保证数据的独立性。
避免循环引用导致的深拷贝问题
在实现深拷贝时，需要特别注意循环引用的问题。如果对象之间存在循环引用，递归复制会导致无限循环，最终导致栈溢出。解决循环引用的方法是使用一个缓存来记录已经复制过的对象，避免重复复制。例如，可以使用 IdentityHashMap 来存储已经复制过的对象。
深拷贝的性能考量
深拷贝的性能开销通常比浅拷贝要大得多，因为它需要递归地复制所有引用对象。在对性能要求较高的场景下，需要谨慎使用深拷贝，或者考虑使用其他优化策略，例如写时复制（copy-on-write）。
