Java基础知识之深拷贝和浅拷贝

对象拷贝是什么?

　　Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。举例说明：比如，对象A和对象B都属于类S，具有属性a和b。那么对对象A进行拷贝操作赋值给对象B就是：B.a=A.a;  B.b=A.b;

　　Java中的对象拷贝主要分为：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)。

　　Java中的数据类型分为基本数据类型和引用数据类型。对于这两种数据类型，在进行赋值操作、用作方法参数或返回值时，会有值传递和引用（地址）传递的差别。所以就会导致属性值修改后,是否会对其他对象有影响.(如果是值传递的,就不会有影响,不过如果是地址传递的,修改后,之前的数据会受影响).

浅拷贝（Shallow Copy）：

　　①对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。

　　②对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

浅拷贝的特点:

　　(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。
　　(2) 对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。改变其中一个，会对另外一个也产生影响。

深拷贝（Deep Copy）：

　　首先介绍对象图的概念。设想一下，一个类有一个对象，其成员变量中又有一个对象，该对象指向另一个对象，另一个对象又指向另一个对象，直到一个确定的实例。这就形成了对象图。那么，对于深拷贝来说，不仅要复制对象的所有基本数据类型的成员变量值，还要为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象图进行拷贝！

　　简单地说，深拷贝对引用数据类型的成员变量的对象图中所有的对象都开辟了内存空间；而浅拷贝只是传递地址指向，新的对象并没有对引用数据类型创建内存空间。

深拷贝的特点:

　　(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
　　(2) 对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。
　　(3) 对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。
　　(4) 深拷贝相比于浅拷贝速度较慢并且花销较大。

一般的引用传递实现:

　　在我们平时写代码时,用的最多的就是=(引用传递)来进行赋值,这就会导致赋值后,所有属性都将会重新被修改:

public class Student {
    //基本数据类型
    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;
    }

    @Override
    public String toString() {
        return "Student{hashCode:" + this.hashCode() +" "+
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class Teacher {
    //基本数据类型
    private int grad;
    //内部引用类型
    private String name;
    //外部引用类型
    private Student student;

    public int getGrad() {
        return grad;
    }

    public void setGrad(int grad) {
        this.grad = grad;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    @Override
    public String toString() {
        return "Teacher{hashCode:" + this.hashCode() +" "+
                "grad=" + grad +
                ", name='" + name + '\'' +
                ", student=" + student +
                '}';
    }
}

public class TestRefrence {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.setName("studentA");
        student1.setAge(10);
        Teacher teacher1 = new Teacher();
        teacher1.setGrad(1);
        teacher1.setName("teacherA");
        teacher1.setStudent(student1);
        Teacher teacher2 = teacher1;
        teacher2.setGrad(2);
        teacher2.setName("teacherB");
        Student student2 = teacher2.getStudent();
        student2.setName("teacherB");
        student2.setAge(20);
        System.out.println("teacher1:"+teacher1.toString());
        System.out.println("teacher2:"+teacher2.toString());
    }
}

测试结果:

浅拷贝的实现:

　　实现对象拷贝的类，需要实现 Cloneable 接口，并覆写 clone() 方法。

public class StudentPro1 {
    //基本数据类型
    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;
    }

    @Override
    public String toString() {
        return "StudentPro1{studentpro1:" + this.hashCode() +" "+
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class TeacherPro1 implements Cloneable {
    //基本数据类型
    private int grad;
    //内部引用类型
    private String name;
    //外部引用类型
    private StudentPro1 studentPro1;

    public int getGrad() {
        return grad;
    }

    public void setGrad(int grad) {
        this.grad = grad;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public StudentPro1 getStudentPro1() {
        return studentPro1;
    }

    public void setStudentPro1(StudentPro1 studentPro1) {
        this.studentPro1 = studentPro1;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //浅拷贝
        return super.clone();
    }

    @Override
    public String toString() {
        return "TeacherPro1{teacherpro1:" + this.hashCode() + " "+
                "grad=" + grad +
                ", name='" + name + '\'' +
                ", studentPro1=" + studentPro1 +
                '}';
    }
}

测试类:

public class TestShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        StudentPro1 studentPro1 = new StudentPro1();
        studentPro1.setName("studentProA");
        studentPro1.setAge(100);
        TeacherPro1 teacherPro1 = new TeacherPro1();
        teacherPro1.setStudentPro1(studentPro1);
        teacherPro1.setGrad(1);
        teacherPro1.setName("teacherA");
        TeacherPro1 teacherPro2 = (TeacherPro1) teacherPro1.clone();
        teacherPro2.setName("teacherB");
        teacherPro2.setGrad(2);
        StudentPro1 studentPro2 = teacherPro2.getStudentPro1();
        studentPro2.setName("studentProB");
        studentPro2.setAge(200);
        System.out.println("teacher1:"+teacherPro1.toString());
        System.out.println("teacher2:"+teacherPro2.toString());

    }
}

测试结果:

　　我们发现虽然teacher1和teacher2的hashCode不一样,但是他们的内部引用类型StudentPro的hashCode是一样的.

深拷贝的实现:

　　对于 TeacherPro的引用类型的成员变量 StudentPro ，需要实现 Cloneable 并重写 clone() 方法。

　　在 TeacherPro的 clone() 方法中，需要拿到拷贝自己后产生的新的对象，然后对新的对象的引用类型再调用拷贝操作，实现对引用类型成员变量的深拷贝。

public class StudentPro implements Cloneable {
    //基本数据类型
    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;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "StudentPro{studentPro:" + this.hashCode() + " "+
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class TeacherPro implements Cloneable {
    //基本数据类型
    private int grad;
    //内部引用类型
    private String name;
    //外部引用类型
    private Student student;
    //外部引用类型
    private StudentPro studentPro;
    public int getGrad() {
        return grad;
    }

    public void setGrad(int grad) {
        this.grad = grad;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public StudentPro getStudentPro() {
        return studentPro;
    }

    public void setStudentPro(StudentPro studentPro) {
        this.studentPro = studentPro;
    }

    @Override
    public String toString() {
        return "TeacherPro{teacherPro:" + this.hashCode() + " "+
                "grad=" + grad +
                ", name='" + name + '\'' +
                ", student=" + student +
                ", studentPro=" + studentPro +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //深拷贝
        TeacherPro teacherPro = (TeacherPro) super.clone();
        teacherPro.studentPro = (StudentPro) studentPro.clone();
        return teacherPro;
    }
}

测试类:

public class TestDeepCopy1 {
    public static void main(String[] args) throws CloneNotSupportedException{
        StudentPro studentPro1 = new StudentPro();
        studentPro1.setName("studentProA");
        studentPro1.setAge(100);
        TeacherPro teacherPro1 = new TeacherPro();
        teacherPro1.setStudentPro(studentPro1);
        teacherPro1.setGrad(1);
        teacherPro1.setName("teacherA");
        TeacherPro teacherPro2 = (TeacherPro) teacherPro1.clone();
        teacherPro2.setName("teacherB");
        teacherPro2.setGrad(2);
        StudentPro studentPro2 = teacherPro2.getStudentPro();
        studentPro2.setName("studentProB");
        studentPro2.setAge(200);
        System.out.println("teacher1:"+teacherPro1.toString());
        System.out.println("teacher2:"+teacherPro2.toString());
    }
}

测试结果:

 由输出结果可见，深拷贝后，不管是基础数据类型还是引用类型的成员变量，修改其值都不会相互造成影响。

通过对象序列化实现深拷贝:

　　虽然层次调用clone方法可以实现深拷贝，但是显然代码量实在太大。特别对于属性数量比较多、层次比较深的类而言，每个类都要重写clone方法太过繁琐。

　　将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。

public class StudentPlus implements Serializable {
    //基本数据类型
    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;
    }

    @Override
    public String toString() {
        return "StudentPlus{studentPlus:" + this.hashCode()+ " "+
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class TeacherPlus implements Serializable {
    //基本数据类型
    private int grad;
    //内部引用类型
    private String name;
    //外部引用类型
    private StudentPlus studentPlus;

    public int getGrad() {
        return grad;
    }

    public void setGrad(int grad) {
        this.grad = grad;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public StudentPlus getStudentPlus() {
        return studentPlus;
    }

    public void setStudentPlus(StudentPlus studentPlus) {
        this.studentPlus = studentPlus;
    }

    @Override
    public String toString() {
        return "TeacherPlus{teacherPlus:" + this.hashCode() +" "+
                "grad=" + grad +
                ", name='" + name + '\'' +
                ", studentPlus=" + studentPlus +
                '}';
    }
}

测试类:

public class TestDeepCopy {
    public static void main(String[] args) {
        StudentPlus studentPlus = new StudentPlus();
        studentPlus.setName("studentPlusA");
        studentPlus.setAge(10);
        TeacherPlus teacherPlus1 = new TeacherPlus();
        teacherPlus1.setName("teacherPlusA");
        teacherPlus1.setGrad(1);
        teacherPlus1.setStudentPlus(studentPlus);
        //通过序列化方法实现深拷贝
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        ObjectOutputStream oos= null;
        try {
            oos = new ObjectOutputStream(bos);
            oos.writeObject(teacherPlus1);
            oos.flush();
            ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
            TeacherPlus teacherPlus2 = (TeacherPlus) ois.readObject();
            teacherPlus2.setName("teacherPlusB");
            teacherPlus2.setGrad(2);
            StudentPlus studentPlus2 = teacherPlus2.getStudentPlus();
            studentPlus2.setName("studentPlusB");
            studentPlus2.setAge(20);
            System.out.println("teacherPlus1:"+teacherPlus1.toString());
            System.out.println("teacherPlus2:"+teacherPlus2.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

测试结果: