深拷贝（deep clone）和浅拷贝（shallow clone）

一、浅复制与深复制的概念

1、浅复制

被复制的对象的所有变量都含有与原来对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

2、深复制

被复制对象的所有变量都含有与原来对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过得新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

二、Java中对象的复制

1、Java的clone()方法（定义在Object类中）。

clone()方法将对象复制了一份并返回给调用者。一般而言，clone方法满足：

• 对任何对象，都有x.clone() != x;
  说明：克隆对象与原对象不是同一个对象。
• 对任何的对象x，都有x.clone.getClass() == x.getClass();
  说明：克隆对象与原对象类型一样。
• 如果对象x的equals方法定义恰当，那么x.clone().equals(x)应该成立。

2、Java中对象的克隆

（1）为了获取对象的一份拷贝，我们可以利用Object类的clone()方法；
（2）在派生类中覆盖基类的clone()方法，并声明为public（Object类中的clone方法为protected）；
（3）在派生类的的clone()方法中，调用super.clone()；
（4）在派生类中实现Cloneable接口。

3、说明

（1）为什么在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？

• 因为在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间。

（2）继承自java.lang.Object类的clone()方法是浅复制

4、CloneTest2示例

CloneTest2代码中展示了二-2中Java对象的克隆，其中第一个clone()方法(注释掉的代码)验证了继承自java.lang.Object类的clone()方法是浅复制。第二个clone()方法为修改后的深复制的代码。

public class CloneTest2
{
    public static void main(String[] args) throws CloneNotSupportedException
    {
        Teacher teacher = new Teacher();
        teacher.setAge(40);
        teacher.setName("zhanglaoshi");
        
        Student2 student2 = new Student2();
        student2.setAge(15);
        student2.setName("xiaoming");
        student2.setTeacher(teacher);
        
        Student2 s2 = student2.clone();
        
        
        System.out.println(s2.getAge());
        System.out.println(s2.getName());
        
        teacher.setName("teacher lee");
        System.out.println(student2.getTeacher().getName());
        System.out.println(s2.getTeacher().getName());
        
    }
}

class Teacher implements Cloneable
{
    int age;
    String name;
    
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    
    @Override
    public Object clone() throws CloneNotSupportedException
    {
        Object object = super.clone();
        return object;
    }   
}

class Student2 implements Cloneable
{
    int age;
    String name;
    Teacher teacher;
    
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public Teacher getTeacher()
    {
        return teacher;
    }
    public void setTeacher(Teacher teacher)
    {
        this.teacher = teacher;
    }
    
    //继承自java.lang.Object类的clone()方法是浅复制
//  @Override
//  public Object clone() throws CloneNotSupportedException
//  {
//      Object object = super.clone();
//      return object;
//  }
    
    //实现深复制
    @Override
    public Student2 clone() throws CloneNotSupportedException
    {
        //先进行浅复制
        Student2 student2 = (Student2)super.clone();
        //再将要复制对象中所引用的对复制一遍
        student2.setTeacher((Teacher)student2.getTeacher().clone());
        return student2;
    }
}

• 用第一个clone()方法时，当修改了teacher的名字时，会发现我们复制的student对象中teacher的名字也跟着变了。验证了继承自java.lang.Object类的clone()方法是浅复制。程序执行结果如下：

  
  
  

  image.png

• 用第二个clone()方法时，当修改了teacher的名字时，会发现我们复制的student对象中teacher的名字没有跟着变。验证实现了深复制。运行结果如下：

  
  
  

  image.png

三、利用序列化来做深复制

1、序列化与反序列化

把对象写到流里的过程是序列化（Serialization）过程，而把对象从流中读出来的过程则叫做反序列化（Deserialization）过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM中。

2、利用序列化来做深复制

在Java语言中深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。

3、两点说明

• 这样做的前提是对象以及对象内部所有引用到的对象是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。
• Cloneable和Seriable都是Marker Interface，也就是说它们只是一个标识接口，没有定义任何方法。

4、CloneTest3示例用序列化实现了深复制

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class CloneTest3
{
    public static void main(String[] args) throws ClassNotFoundException, IOException
    {
        Teacher3 teacher3 = new Teacher3();
        teacher3.setAge(40);
        teacher3.setName("Teacher zhang");
        
        Student3 s1 = new Student3();
        s1.setAge(16);
        s1.setName("xiaoming");
        s1.setTeacher(teacher3);
        
        Student3 s2 = (Student3)s1.deepClone();
        System.out.println(s2.getAge());
        System.out.println(s2.getName());
        System.out.println(s2.getTeacher().getName());
        
        teacher3.setName("hahahha");
        
        System.out.println(s1.getTeacher().getName());
        System.out.println(s2.getTeacher().getName());
        
    }

}

class Teacher3 implements Serializable
{
    
    private static final long serialVersionUID = 2456812179890003332L;
    
    private int age;
    private String name;
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }   
}

class Student3 implements Serializable
{
    
    private static final long serialVersionUID = 3565617956555242115L;
    
    private int age;
    private String name;
    private Teacher3 teacher;
    
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public Teacher3 getTeacher()
    {
        return teacher;
    }
    public void setTeacher(Teacher3 teacher)
    {
        this.teacher = teacher;
    }
    
    
    public Object deepClone() throws IOException, ClassNotFoundException
    {
        /**
         * 使用ObjectOutputStream将对象序列化到字节数组节点流
         */
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        
        /**
         * 使用ObjectInputStream将对象从字节数组节点流取出并恢复（反序列化）
         */
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        
        return ois.readObject();
    }
    
}

• 当改变了teacher3的name属性值后，运行程序，发现只有s1对象中teacher中的name属性值改变，复制得到的s2对象中teacher的name属性值并为改变。验证深拷贝实现成功。

  
  
  

  image.png