【Java】浅拷贝和深拷贝简述

　　之前在讲原型模式的时候已经提到过浅拷贝和深拷贝的概念。这里我再单独拿出来写一篇做下叙述，如果有说的不对的地方，还望各位指正。

前言

　　在Java中关于对象的拷贝我们大致可以分为两种，一种是浅拷贝（也叫引用拷贝），另外一种是深拷贝（也称值拷贝）。

示例

　　我相信绝大多数程序员Ctrl+C、Ctrl+V都玩的很溜，博主也一样哈。工作周报我觉得大家在熟悉不过了吧。以我自身写周报为例子，为了节省自己的时间（主要还是自己懒），我基本都是Ctrl+C、Ctrl+V别人写好的周报格式进行现改。一人一份工作周报，总不能有两个人的周报一字不差、一模一样的吧。或多或少还是有点出入的，比如改下标题，发件人，工作内容等等。

浅拷贝

　　定义：被复制的对象所有的变量都含有与原来对象相同的值，所有的对其他对象的引用都仍然指向原来的对象（即原始的对象和其副本引用同一个对象）。
　　
　　先来看下程序代码

/**
 * 工作周报类
 * @author zhh
 * @date 2017-08-23 上午11:03:47
 */
class Report implements Cloneable {

    private String title;       // 标题
    private String sender;      // 发送者
    private String receiver;    // 接收者
    private ArrayList<String> content; //内容

    public Report(String title, String sender, String receiver) {
        this.title = title;
        this.sender = sender;
        this.receiver = receiver;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getSender() {
        return sender;
    }
    public void setSender(String sender) {
        this.sender = sender;
    }
    public String getReceiver() {
        return receiver;
    }
    public void setReceiver(String receiver) {
        this.receiver = receiver;
    }
    public ArrayList<String> getContent() {
        return content;
    }
    public void setContent(ArrayList<String> content) {
        this.content = content;
    }

    public void print() {
        System.out.println(this);
    }

    @Override
    public Report clone() {
        Report msg = null;
        try {
            msg = (Report) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return msg;
    }

    @Override
    public String toString() {
        return "Report [title=" + title + ", sender=" + sender + ", receiver=" + receiver + ", content=" + content
                + "]";
    }

}

　　举个例子，我这里拷贝下公司UI小姐姐的周报模板现改现卖，像标题，发送者，内容什么的大致还是得改改。写个主方法测试下。

    public static void main(String[] args) {
        Report report = new Report("yg工作周报", "yg", "boss");
        ArrayList<String> content = new ArrayList<>();
        content.add("1.参加研讨会议, 确定需求");
        content.add("2.设计首页的icon以及界面");
        report.setContent(content);

        Report report1 = report.clone();
        report1.setTitle("zhh工作周报");
        report1.setSender("zhh");
        ArrayList<String> content1 = report1.getContent();
        content1.set(1, "2.搭建基础的后台框架");
        report1.setContent(content1);

        System.out.println("----------UI小姐姐工作周报--------------");
        report.print();
        System.out.println("----------我的工作周报--------------");
        report1.print();

    }

　　程序运行的结果如下:

----------UI小姐姐工作周报--------------
Report [title=yg工作周报, sender=yg, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.搭建基础的后台框架]]
----------我的工作周报--------------
Report [title=zhh工作周报, sender=zhh, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.搭建基础的后台框架]]

　　虽然执行没有发生什么异常，但其结果显然是不对的。UI小姐姐跟我干的活一样啦？老板看了显然也是一脸懵逼的。搞不好我也就被UI小姐姐给顶替掉了（开个玩笑哈）。

　　但为什么会这样呢？克隆以后为什么我的工作内容把UI的工作内容替换了呢？而其他标题、发送者却没有这种情况。
　　我们知道在Java当中Object类是所有类的顶级父类，而其clone方法只会拷贝对象中的基本数据类型，对于数组、容器对象、引用对象等都不会拷贝。程序Report类自写的clone方法中 msg = (Report) super.clone(); 就是调用了Object类的clone方法。String类虽然也是引用类型，但由于其的特殊性（final 类），虽然复制的引用，但是修改值的时候并没有改变被复制对象的值；而ArrayList复制的仅仅是引用，导致原本引用和副本引用指向同一对象，所以上述代码修改任意一个对象的content都会影响另外一个。

深拷贝

　　根据上面的分析，浅拷贝是无法去完成含有除基本数据类型之外对象的拷贝的。
　　定义：被复制的对象所有的变量都含有与原来对象相同的值，所有的对其他对象的引用也都指向复制过的新的对象（即原始的对象和其副本引用不同对象）。
　　
　　这里我们自己实现深拷贝，让原始对象和其副本对象指向不同对象。
　　其实代码和浅拷贝大致相同，差别只是在Report类重写的clone方法，这里我就单独拿出来写下了。

...

    @Override
    public Report clone() {
        Report msg = null;
        try {
            msg = (Report) super.clone();
            // 将引用对象 content 也 clone下
            msg.content = (ArrayList<String>) this.content.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return msg;
    }
...

　　测试的主方法同浅拷贝，不做修改直接运行，运行的结果如下：

----------UI小姐姐工作周报--------------
Report [title=yg工作周报, sender=yg, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.设计首页的icon以及界面]]
----------我的工作周报--------------
Report [title=zhh工作周报, sender=zhh, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.搭建基础的后台框架]]

　　这里你可以看到，拷贝后两者的内容之间并没有相互的影响。

扩展

　　深拷贝除了上述实现方式外，也可以用序列化来实现。

/**
 * 序列化实现深拷贝
 * @author zhh
 * @date 2017-08-23 下午1:04:44
 */
class Report implements Serializable {

    private static final long serialVersionUID = -760030405417987698L;

    private String title;       // 标题
    private String sender;      // 发送者
    private String receiver;    // 接收者
    private ArrayList<String> content; //内容

    public Report(String title, String sender, String receiver) {
        this.title = title;
        this.sender = sender;
        this.receiver = receiver;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getSender() {
        return sender;
    }
    public void setSender(String sender) {
        this.sender = sender;
    }
    public String getReceiver() {
        return receiver;
    }
    public void setReceiver(String receiver) {
        this.receiver = receiver;
    }
    public ArrayList<String> getContent() {
        return content;
    }
    public void setContent(ArrayList<String> content) {
        this.content = content;
    }

    public void print() {
        System.out.println(this);
    }

    @Override
    public Report clone() {
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            // 1.将对象序列化成流
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            // 2.将流序列化成对象
            bis = new ByteArrayInputStream(bos.toByteArray());;
            ois = new ObjectInputStream(bis);
            return (Report) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }

    @Override
    public String toString() {
        return "Report [title=" + title + ", sender=" + sender + ", receiver=" + receiver + ", content=" + content
                + "]";
    }

}

　　测试的主方法同浅拷贝，不做修改直接运行，运行的结果如下：

----------UI小姐姐工作周报--------------
Report [title=yg工作周报, sender=yg, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.设计首页的icon以及界面]]
----------我的工作周报--------------
Report [title=zhh工作周报, sender=zhh, receiver=boss, content=[1.参加研讨会议, 确定需求, 2.搭建基础的后台框架]]

　　事实证明，用序列化来实现对象的深拷贝也是可行的。主要原因是在对象序列化流的过程当中，写在流里面的是对象的一个拷贝，而原本的对象仍然存在堆内。

序列化实现深拷贝过程中，我们实现了Serializable这个空接口，来标明Report类可序列化。
这里要说一下 为什么要给 serialVersionUID 赋值
举个例子，当对象序列化存到硬盘上后，比方我修改了这个对象的属性，那么在反序列化的过程就会出现异常。
一旦我们给 serialVersionUID 赋值，当序列化和反序列化的 serialVersionUID 相同的时候，中间过程修改对象属性就不会像上面抛出异常，而是以属性的对应类型赋默认值（如String类型默认为null，int类型默认为0等等）