Java 深拷贝和浅拷贝

Java 中的深拷贝和浅拷贝是针对对象复制而言的。

浅拷贝（Shallow Copy）

当对象进行浅拷贝时，只会复制对象本身和其中的基本数据类型属性，而不会复制引用对象的实际内容。具体而言，浅拷贝只会创建一个新的对象，并将原始对象中非静态字段的值复制到新对象中。如果该字段是引用类型，则仍然保留该引用，而不是创建一个新对象并将该引用指向新对象。

class Example implements Cloneable {
   public int num;
   public String str;
   public Object obj;
   
   @Override
   protected Object clone() throws CloneNotSupportedException {
      return super.clone();
   }
}

class Main {
   public static void main(String[] args) {
      Example ex1 = new Example();
      ex1.num = 2;
      ex1.str = "Hello";
      ex1.obj = new Object();
      
      try {
         Example ex2 = (Example) ex1.clone();
         System.out.println(ex1.obj == ex2.obj); // true, both point to the same object.
      } catch (CloneNotSupportedException e) {
         e.printStackTrace();
      }
   }
}

在上面的示例中，我们可以看到 ex1 和 ex2 都有相同的值（整数 2 和字符串"Hello"），并且它们都引用了相同的 obj 对象。这说明在进行浅拷贝时，obj 对象没有被复制，而是被共享。

深拷贝（Deep Copy）

相反，当对象进行深拷贝时，完全复制对象及其引用对象的实际内容，而不是只复制引用。具体而言，深拷贝将创建一个新对象，并递归地复制原始对象及其所有子对象中的所有字段和可变对象。这样，原始对象和副本之间就不存在任何共享对象。

import java.io.*;

class MyClass implements Serializable {
    public int num;
    public String str;

    public MyClass(int num, String str) {
        this.num = num;
        this.str = str;
    }

    @Override
    public String toString() {
        return "MyClass{" +
                "num=" + num +
                ", str='" + str + '\'' +
                '}';
    }
}

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        MyClass original = new MyClass(123, "Hello World");

        //使用序列化进行深拷贝
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(original);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);

        MyClass deepCopy = (MyClass) ois.readObject();

        //检查深拷贝是否成功
        System.out.println("原始对象: " + original);
        System.out.println("深拷贝后对象: " + deepCopy);

        //改变原始对象数据，检查是否影响到了深拷贝对象
        original.num = 321;
        original.str = "Goodbye World";

        System.out.println("修改后的原始对象: " + original);
        System.out.println("深拷贝后对象: " + deepCopy);
    }
}

以下是Java中进行深拷贝的示例代码：

import java.io.*;

class MyClass implements Serializable {
    public int num;
    public String str;

    public MyClass(int num, String str) {
        this.num = num;
        this.str = str;
    }

    @Override
    public String toString() {
        return "MyClass{" +
                "num=" + num +
                ", str='" + str + '\'' +
                '}';
    }
}

执行结果
原始对象: MyClass{num=123, str=‘Hello World’}
深拷贝后对象: MyClass{num=123, str=‘Hello World’}
修改后的原始对象: MyClass{num=321, str=‘Goodbye World’}
深拷贝后对象: MyClass{num=123, str=‘Hello World’}

该示例中定义了一个自定义类 MyClass ，并实现了 Serizalizable 接口。接着，在 main 方法中，创建了一个 original 对象作为原始对象，然后使用序列化的方式进行深拷贝，将 original 拷贝到 deepCopy 中。最后，通过修改原始对象检查是否会影响到深拷贝对象。