clone

使用Object.clone() 创建出一个和原对象内容一样，地址不一样的对象

浅拷贝

实现Cloneable接口，重写clone方法，调用父类的clone方法，将返回值类型强转成本类类型

  1. @Data
  2. public class Person implements Cloneable{
  3.     private String name;
  4.     private int age;
  5.     private Children child;
  7.     @Override
  8.     public String toString() {
  9.         return "Person{" +
  10.                 "name='" + name + '\'' +
  11.                 ", age=" + age +
  12.                 '}';
  13.     }
  15.     @Override
  16.     public Person clone() throws CloneNotSupportedException {
  17.         return (Person) super.clone();
  18.     }
  19. }

浅拷贝的缺点：
拷贝出来的对象的引用类型的成员变量 child 是同一个引用

clone的深拷贝实现：

  1. @Override
  2. public Person clone() throws CloneNotSupportedException {
  3.     Person clone = (Person) super.clone();
  4.     clone.setChild(child.clone());
  5.     return clone;
  6. }

IO实现深拷贝

  1. // Person需要实现Serializable
  2. @Override
  3. public Person clone() {
  5.     try {
  6.         //1. 创建ByteArrayOutputStream，将数据可以转换成字节
  7.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  8.         //2. 创建ObjectOutputStream，关联ByteArrayOutputStream
  9.         ObjectOutputStream out = new ObjectOutputStream(bout);
  10.         //3. 使用ObjectOutputStream的writeObject，读取要复制的对象
  11.         out.writeObject(this);
  12.         //4. 使用ByteArrayInputStream读取ByteArrayOutputStream的转换的对象字节数据
  13.         ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
  14.         //5. 创建ObjectInputStream读取对象字节数据，创建新的对象
  15.         ObjectInputStream in = new ObjectInputStream(bin);
  16.         Person clone = (Person) in.readObject();
  17.         return clone;
  18.     } catch (Exception e) {
  19.         e.printStackTrace();
  20.         return null;
  21.     }
  22. }