Java 深拷贝和浅拷贝区别是什么？

Java 深拷贝和浅拷贝区别是什么？

深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是关于对象拷贝的两个概念。

1. 浅拷贝：

   • 浅拷贝是指在拷贝对象时，只拷贝对象本身和对象中的基本数据类型，不拷贝对象内部的引用类型对象。

   • 浅拷贝创建一个新对象，但其内部的引用类型字段仍然指向原始对象中相同的对象。

   • 使用Object.clone()方法、clone()方法或一些库方法（如Arrays.copyOf()）进行浅拷贝。

   class Person implements Cloneable {
       private String name;
       private Address address;
   
       public Person(String name, Address address) {
           this.name = name;
           this.address = address;
       }
   
       public Object clone() throws CloneNotSupportedException {
           return super.clone();
       }
   }
   
   class Address {
       private String city;
   
       public Address(String city) {
           this.city = city;
       }
   }
   
   public class ShallowCopyExample {
       public static void main(String[] args) throws CloneNotSupportedException {
           Address address = new Address("City");
           Person originalPerson = new Person("John", address);
   
           // 浅拷贝
           Person clonedPerson = (Person) originalPerson.clone();
   
           System.out.println(originalPerson == clonedPerson);  // false
           System.out.println(originalPerson.getAddress() == clonedPerson.getAddress());  // true
       }
   }
   

2. 深拷贝：

   • 深拷贝是指在拷贝对象时，不仅拷贝对象本身，还会递归拷贝对象内部的引用类型对象。

   • 深拷贝创建一个新对象，同时递归拷贝对象内部的引用类型字段。

   • 实现深拷贝的方法包括手动编写递归拷贝代码、使用序列化/反序列化、使用第三方库等。

   import java.io.*;
   
   class DeepCopyPerson implements Serializable {
       private String name;
       private DeepCopyAddress address;
   
       public DeepCopyPerson(String name, DeepCopyAddress address) {
           this.name = name;
           this.address = address;
       }
   
       public DeepCopyPerson deepCopy() throws IOException, ClassNotFoundException {
           // 使用序列化和反序列化实现深拷贝
           ByteArrayOutputStream bos = new ByteArrayOutputStream();
           ObjectOutputStream oos = new ObjectOutputStream(bos);
           oos.writeObject(this);
   
           ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
           ObjectInputStream ois = new ObjectInputStream(bis);
   
           return (DeepCopyPerson) ois.readObject();
       }
   
       public DeepCopyAddress getAddress() {
           return address;
       }
   }
   
   class DeepCopyAddress implements Serializable {
       private String city;
   
       public DeepCopyAddress(String city) {
           this.city = city;
       }
   }
   
   public class DeepCopyExample {
       public static void main(String[] args) throws IOException, ClassNotFoundException {
           DeepCopyAddress address = new DeepCopyAddress("City");
           DeepCopyPerson originalPerson = new DeepCopyPerson("John", address);
   
           // 深拷贝
           DeepCopyPerson clonedPerson = originalPerson.deepCopy();
   
           System.out.println(originalPerson == clonedPerson);  // false
           System.out.println(originalPerson.getAddress() == clonedPerson.getAddress());  // false
       }
   }
   

在上述深拷贝的例子中，通过序列化和反序列化实现了深拷贝。注意，被拷贝的类需要实现Serializable接口。深拷贝的实现方式可以根据具体情况选择不同的方法。