Java 深拷贝与浅拷贝

1 Java 中对象的创建

clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。

那么在java语言中，创建对象可以通过：
1，使用new操作符创建一个对象
2，使用clone方法复制一个对象

使用clone而不是new一个类 的原因：
clone 方法是native 方法，效率要远高于非native的方法

关于 clone（） 方法

clone 是定义在Object 类下的基本方法，定义如下：

protected native Object clone() throws CloneNotSupportedException;

可以看到
1）clone方法是 protected 修饰的native 方法
2）克隆方法返回的是一个Object对象，所以必须要经过强制类型转换。

复制对象 or 复制引用

// ‘=’ 赋值
        Clones c0 = new Clones("abc",123);
        Clones c1 = c0;
        System.out.println(c0);
        System.out.println(c1);

输出：

com.something.Clones@1581593
com.something.Clones@1581593

可以看出打印地址是相同的，则肯定是同一个对象。c0 c1 只是一个引用，他们指向同一个对象。

而使用clone 方法时：

    Clones c0 = new Clones("abc",123);
        Clones c1 = (Clones)c0.clone();
        System.out.println(c0);
        System.out.println(c1);

打印结果：

com.something.Clones@1f06dc3
com.something.Clones@1b64e6a

两个对象的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量。

在源码的注释中可以看到：

/**
* Creates and returns a copy of this object. The precise meaning
* of “copy” may depend on the class of the object. The general
* intent is that, for any object {@code x}, the expression:
* x.clone() != x
* will be true, and that the expression:
* x.clone().getClass() == x.getClass() 所属类形同
* will be {@code true}, but these are not absolute requirements.
* While it is typically the case that:
* x.clone().equals(x) 对象内容相同
* will be {@code true}, this is not an absolute requirement.

x.clone() != x 必须为真，也就是对于**基础类型**来说，其克隆后在堆中有两个**独立且内容相同的内存区域**。而对于**引用类型**来说，其**引用也不相同。**也就是说克隆对象和原始对象在java 堆(heap)中是两个独立的对象。

2 深拷贝 浅拷贝

拷贝是复制一个对象的副本。但是一个对象中有可能有基本数据类型，也有对象数据类型。

1. shallow clone 浅拷贝：要克隆的对象，对于基本数据类型的属性，复制一个新的，对于非基本类型的属性，仅复制引用给新的对象，而指向同一个对象

2. deep clone 深拷贝： 引用的对象的值也被改变了。深复制把要复制的对象所引用的对象都复制了一遍。

1，浅拷贝：

• 实现java.lang.Cloneable 接口。
  Cloneable 接口是一个标识接口，不包含任何方法。调用Object 类中的clone方法必须要实现Cloneable 接口，否则会抛出异常
• 重写java.lang.Object.clone()方法。
  将clone权限设置为public。 clone方法返回一个Object对象的拷贝。注意：1，返回的是一个新的对象,2，返回的对象与new操作符返回的区别就是这个拷贝已经包含了一些原来对象的信息。

clone 方法产生的效果：先在内存中开辟一块和原始对象一样的空间，然后鸳鸯拷贝原始对象中的内容。

public class Product implements Cloneable {   
    private String name;   

    public Object clone() {   
        try {   
            return super.clone();   
        } catch (CloneNotSupportedException e) {   
            return null;   
        }   
    }   
}  

2，深拷贝

即对非基本类型的属性也实现拷贝。

对于要拷贝的类和类中所有的非基本数据类型的属性对应的类：

• 都实现java.lang.Cloneable接口
• 都重写java.lang.Object.clone()方法

深拷贝与浅拷贝：

深拷贝：

public class CloneTest {

    public static void main(String[] args) throws CloneNotSupportedException{

        Head  head = new Head();
        Body  body = new Body(head);
        Body  newBody = body.clone();
        System.out.println(body.head==newBody.head);
    }

}
class Body implements Cloneable{  
    public Head head;  
    public Body() {}  
    public Body(Head head) {this.head = head;}  


    protected Body clone () throws CloneNotSupportedException{
        Body  newBody = (Body) super.clone();
        //将newBody 中的head也进行克隆
        newBody.head = (Head) head.clone();
        return  newBody;
    }


}  
class Head implements Cloneable{  
    public  int face;  

    public Head() {}  
    public Head(int face){this.face = face;}  

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

输出结果为false。两个body 中的head 也指向了不同的Head 对象。

当然，如果Head 中的Face 依旧是对象的话，上面的拷贝只是完成了：

如果进一步深拷贝的话需要在Head 对象中重写clone 方法。

3 使用序列化实现深拷贝

序列化即是把对象写到流里面的过程；反序列化即是把对象从流中读取出来的过程。写在流里的是对象的一个拷贝，而原来的对象仍然在JVM里面。

实现过程的描述：
前提是对象以及对象内部所有用到的对象都是可序列化的，否则就需要考虑把那些不可序列化的对象标记为transient，从而把它排除到复制范围之外。

然后使对象实现Serializable接口。

把对象写入到一个流里（不用依赖于文件，直接暂存在内存中即可），在从流里读取出来，便得到了一个深复制的对象。

参考：
http://blog.csdn.net/zhangjg_blog/article/details/18369201
http://www.itzhai.com/java-based-notebook-the-object-of-deep-and-shallow-copy-copy-copy-implement-the-cloneable-interface-serializing-deep-deep-copy.html#read-more
http://blog.csdn.net/mazhimazh/article/details/16828505#comments
http://blog.sina.com.cn/s/blog_6145ed810100uy8b.html