Java中的深浅拷贝

1.什么是深拷贝和浅拷贝

浅拷贝和深拷贝都是对一个已有对象的操作，编译系统会自动调用一种构造函数——拷贝构造函数，如果用户未定义拷贝构造函数，则会调用默认拷贝构造函。
在java中，一般使用=好做赋值操作的时候，对于基本数据类型，实际上是拷贝他的值，但是对于对象而言，其实赋值的指示这个对象的引用，将原对象的引用传递过去，他们实际上还是指向的用一个对象。
而浅拷贝和深拷贝就是在这个基础之上做的区分，如果在拷贝这个对象的时候，只对基本数据类型进行了拷贝，而对引用数据类型只是进行了引用的传递，而没有创建一个新的对象，那就是浅拷贝。反之，在对引用数据类型进行拷贝的时候，新创建了一个新的对象，并完全复制了其内的成员变量，那么这就是深拷贝。实际浅拷贝和深拷贝只是相对的，如果一个对象内部只有基本数据类型，那用 clone() 方法获取到的就是这个对象的深拷贝，而如果其内部还有引用数据类型，那用 clone() 方法就是一次浅拷贝的操作。
clone在平时项目的开发中可能用的不是很频繁，但是区分深拷贝和浅拷贝会让我们对java内存结构和运行方式有更深的了解。深拷贝和彻底深拷贝，在创建不可变对象时，可能对程序有着微妙的影响，可能会决定我们创建的不可变对象是不是真的不可变。

简单总结

1.1 浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
1.2 深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

2.java中的clone方法

在编程中，经常会遇到从一个对象A创建出另外一个与A具有相同状态的对象B，并且对B的修改不会影响到A的状态，Java中提供clone（）方法来满足此需求，Java中的类默认继承自Object类，而Object类提供了clone()方法。方法的作用是返回一个Object对象的复制。这个复制函数返回的是一个全新的对象而不是一个引用。

    protected native Object clone() throws CloneNotSupportedException; 
    Cloneable:CloneNotSupportedException

只有子类实现了Cloneable接口后才可以使用Object类提供的clone方法，在类中自定义clone()。（异常原因）
clone顾名思义就是复制，在java语言中，clone方法被对象调用，所以会复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新对象。

在java语言中，使用new操作创建一个对象与使用clone方法复制一个对象有什么不同？

使用new操作创建对象本意是分配内存。程序只领到new操作符时，首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这就叫对象的初始化。对象初始化完毕后，可以把引用发布到外部，在外部就可以使用这个引用操纵这个对象。

clone在第一步和new相似的，都是分配内存的，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后在使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回，一个新的相同对象就能被创建，同样这个新对象的引用发布到外部。

3.实现深浅拷贝的要求

要想让对象具有拷贝的功能，必须实现Cloneable接口【标识接口（Serializable和Cloneable接口没有任何方法，这种接口称为标识接口。），表示此类允许被clone】并且在类中自定义clone调用Object类提供的继承权限clone方法

4.浅拷贝如何实现

4.1 包含的其他类继续实现Cloneable接口，并且调用clone方法(递归实现clone)
实现代码如下：

package JavaSe.Io;
class Teacher implements Cloneable{
    private String name;
    private String job;
    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
}
class Student implements Cloneable{
    private String name;
    private int age;
    private Teacher teacher;

    public Student clone(){
        Student student=null;
        try{
            //实现拷贝处理，产生一个新的Student对象，拷贝原来的所有属性值
            student =(Student) super.clone();//浅拷贝
        } catch (CloneNotSupportedException e) {
            e.printStackTrace( );
        }
        return student;
    }

    public Student(String name,int age,Teacher teacher){
        this.name=name;
        this.age=age;
        this.teacher=teacher;
    }
    public void setName(String name) {
        this.name = name;

    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}

public class DepthCopy {
    public static void main(String[] args) {
        Teacher teacher=new Teacher("马云","teacher");
        Student student=new Student("我",20,teacher);
        Student student1=student.clone();
        System.out.println(student);
        System.out.println(student1);
        System.out.println("-----------");
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        System.out.println(student1.getTeacher().getName());
        System.out.println(student1.getTeacher().getJob());
        System.out.println("------------");
        System.out.println(teacher==student1.getTeacher());

    }
}

5.深拷贝如何实现

5.1 包含的其他类继续实现Cloneable接口，并且调用clone方法(递归实现clone)

package JavaSe.Io;
class Teacher implements Cloneable{
    private String name;
    private String job;
    public Teacher clone(){
        Teacher teacher=null;
            try{
              teacher =(Teacher) super.clone();//深拷贝
            } catch (CloneNotSupportedException e) {
                e.printStackTrace( );
            }
            return teacher;
    }

    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
}
class Student implements Cloneable{
    private String name;
    private int age;
    private Teacher teacher;

    public Student clone(){
        Student student=null;
        try{
            //实现拷贝处理，产生一个新的Student对象，拷贝原来的所有属性值
            student =(Student) super.clone();//浅拷贝
            student.teacher=this.teacher.clone();//深拷贝（递归实现）
        } catch (CloneNotSupportedException e) {
            e.printStackTrace( );
        }
        return student;
    }

    public Student(String name,int age,Teacher teacher){
        this.name=name;
        this.age=age;
        this.teacher=teacher;
    }
    public void setName(String name) {
        this.name = name;

    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}

public class DepthCopy {
    public static void main(String[] args) {
        Teacher teacher=new Teacher("马云","teacher");
        Student student=new Student("我",20,teacher);
        Student student1=student.clone();
        System.out.println(student);
        System.out.println(student1);
        System.out.println("-----------");
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        System.out.println(student1.getTeacher().getName());
        System.out.println(student1.getTeacher().getJob());
        System.out.println("------------");
        System.out.println(teacher==student1.getTeacher());

    }
}

5.2 使用序列化，使用序列化进行深拷贝时，无需再实现Cloneable接口，只需要实现serializable即可
（序列化可参考序列化与反序列化详解）

package JavaSe.Io;
import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;
import java.io.*;
class Teacher implements Serializable {
    private String name;
    private String job;

    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
}
class Student implements Serializable {
    private String name;
    private int age;
    private Teacher teacher;

    public Student cloneObject() throws IOException, ClassNotFoundException {
        //通过内存进行序列化的读取写入
        //获取内存流
        // 获取序列化的两个核心类
        ByteOutputStream bos=new ByteOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis=new ByteArrayInputStream(bos.getBytes());
        ObjectInputStream ois=new ObjectInputStream(bis);
        return (Student) ois.readObject();
    }

    public Student(String name,int age,Teacher teacher){
        this.name=name;
        this.age=age;
        this.teacher=teacher;
    }
    public void setName(String name) {
        this.name = name;

    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}

public class DepthCopy {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Teacher teacher=new Teacher("马云","teacher");
        Student student=new Student("我",20,teacher);
        Student student1=student.cloneObject();
        System.out.println(student);
        System.out.println(student1);
        System.out.println("-----------");
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        System.out.println(student1.getTeacher().getName());
        System.out.println(student1.getTeacher().getJob());
        System.out.println("------------");
        System.out.println(teacher==student1.getTeacher());

    }
}

6.深浅拷贝存在的问题

浅拷贝：对象值拷贝，对于拷贝而言，拷贝出来的对象仍然保留原对象的所有引用
问题：牵一发而动全身，只要任意一个拷贝对象（或原有对象）中的引用发生改变，所有对象均会受到影响
优点：效率高，相对于深拷贝节约空间
深拷贝：深拷贝出来的对象产生了所有引用的新的对象
问题：深拷贝效率低，且浪费空间。
优点：修改任意一个对象，不会对其他对象产生影响

7.综合使用（延迟拷贝）

延迟拷贝=深拷贝+浅拷贝
读取时使用浅拷贝，如果内容修改时用深拷贝，浅拷贝快于深拷贝