java对象克隆以及深拷贝和浅拷贝

1.什么是"克隆"？

在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能 会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在 Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。 
Java的所有类都默认继承java.lang.Object类，在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点：一是拷贝对象返回的是一个新对象，而不是一个引用。二是拷贝对象与用 new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，而不是对象的初始信息。 

2.怎样应用clone方法

一个很典型的调用clone()代码如下： 

 1 class CloneClass implements Cloneable{ 
 2 　public int aInt; 
 3 　public Object clone(){ 
 4 　　CloneClass o = null; 
 5 　　try{ 
 6 　　　o = (CloneClass)super.clone(); 
 7 　　}catch(CloneNotSupportedException e){ 
 8 　　　e.printStackTrace(); 
 9 　　} 
10 　　return o; 
11 　} 
12 ｝

有三个值得注意的地方，一是希望能实现clone功能的CloneClass类实现了Cloneable接口，这个接口属于java.lang 包，java.lang包已经被缺省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone()方 法。最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或 间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。 

应该说第三点是最重要的，仔细 观察一下Object类的clone()一个native方法，native方法的效率一般来说都是远高于java中的非native方法。这也解释了为 什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了clone功能。对于第二点，也要 观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法，必须继承Object类，在 Java中所有的类是缺省继承Object类的，也就不用关心这点了。然后重写clone()方法。还有一点要考虑的是为了让其它类能调用这个clone 类的clone()方法，重写之后要把clone()方法的属性设置为public。 

那么clone类为什么还要实现 Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对 Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了 super.Clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常。 

3.深拷贝与浅拷贝

浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。举例来说更加清楚：对象A1中包含对B1的引用，B1中包含对C1的引用。浅拷贝A1得到A2，A2 中依然包含对B1的引用，B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归，深拷贝A1得到A2，A2中包含对B2（B1的copy）的引用，B2 中包含对C2（C1的copy）的引用。

若不对clone()方法进行改写，则调用此方法得到的对象即为浅拷贝，下面我们着重谈一下深拷贝。运行下面的程序，看一看浅拷贝：

 1 class Professor0 implements Cloneable {
 2     String name;
 3     int age;
 4  
 5     Professor0(String name, int age) {
 6         this.name = name;
 7         this.age = age;
 8     }
 9  
10     public Object clone() throws CloneNotSupportedException {
11         return super.clone();
12     }
13 }

 1 class Student0 implements Cloneable {
 2     String name;// 常量对象。
 3     int age;
 4     Professor0 p;// 学生1和学生2的引用值都是一样的。
 5  
 6     Student0(String name, int age, Professor0 p) {
 7         this.name = name;
 8         this.age = age;
 9         this.p = p;
10     }
11  
12     public Object clone() {
13         Student0 o = null;
14         try {
15             o = (Student0) super.clone();
16         } catch (CloneNotSupportedException e) {
17             System.out.println(e.toString());
18         }
19  
20         return o;
21     }
22 }

 1 public class ShallowCopy {
 2     public static void main(String[] args) {
 3         Professor0 p = new Professor0("wangwu", 50);
 4         Student0 s1 = new Student0("zhangsan", 18, p);
 5         Student0 s2 = (Student0) s1.clone();
 6         s2.p.name = "lisi";
 7         s2.p.age = 30;
 8         s2.name = "z";
 9         s2.age = 45;
10         System.out.println("学生s1的姓名：" + s1.name + "\n学生s1教授的姓名：" + s1.p.name + "," + "\n学生s1教授的年纪" + s1.p.age);// 学生1的教授
11     }
12 }

运行结果：

s2变了，但s1也变了，证明s1的p和s2的p指向的是同一个对象。这在我们有的实际需求中，却不是这样，因而我们需要深拷贝：

 1 class Professor implements Cloneable {
 2     String name;
 3     int age;
 4  
 5     Professor(String name, int age) {
 6         this.name = name;
 7         this.age = age;
 8     }
 9  
10     public Object clone() {
11         Object o = null;
12         try {
13             o = super.clone();
14         } catch (CloneNotSupportedException e) {
15             System.out.println(e.toString());
16         }
17         return o;
18     }
19 }

 1 class Student implements Cloneable {
 2     String name;
 3     int age;
 4     Professor p;
 5  
 6     Student(String name, int age, Professor p) {
 7         this.name = name;
 8         this.age = age;
 9         this.p = p;
10     }
11  
12     public Object clone() {
13         Student o = null;
14         try {
15             o = (Student) super.clone();
16         } catch (CloneNotSupportedException e) {
17             System.out.println(e.toString());
18         }
19         o.p = (Professor) p.clone();
20         return o;
21     }
22 }

 1 public class DeepCopy {
 2     public static void main(String args[]) {
 3         long t1 = System.currentTimeMillis();
 4         Professor p = new Professor("wangwu", 50);
 5         Student s1 = new Student("zhangsan", 18, p);
 6         Student s2 = (Student) s1.clone();
 7         s2.p.name = "lisi";
 8         s2.p.age = 30;
 9         System.out.println("name=" + s1.p.name + "," + "age=" + s1.p.age);// 学生1的教授不改变。
10         long t2 = System.currentTimeMillis();
11         System.out.println(t2-t1);
12     }
13 }

运行结果：

当然我们还有一种深拷贝方法，就是将对象串行化：

 1 class Professor2 implements Serializable {
 2     /**
 3      * 
 4      */
 5     private static final long serialVersionUID = 1L;
 6     String name;
 7     int age;
 8  
 9     Professor2(String name, int age) {
10         this.name = name;
11         this.age = age;
12     }

 1 class Student2 implements Serializable {
 2     /**
 3      * 
 4      */
 5     private static final long serialVersionUID = 1L;
 6     String name;// 常量对象。
 7     int age;
 8     Professor2 p;// 学生1和学生2的引用值都是一样的。
 9  
10     Student2(String name, int age, Professor2 p) {
11         this.name = name;
12         this.age = age;
13         this.p = p;
14     }
15  
16     public Object deepClone() throws IOException, OptionalDataException,
17             ClassNotFoundException {
18         // 将对象写到流里
19         ByteArrayOutputStream bo = new ByteArrayOutputStream();
20         ObjectOutputStream oo = new ObjectOutputStream(bo);
21         oo.writeObject(this);
22         // 从流里读出来
23         ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
24         ObjectInputStream oi = new ObjectInputStream(bi);
25         return (oi.readObject());
26     }
27  
28 }

 1 public class DeepCopy2 {
 2      
 3     /**
 4      * @param args
 5      */
 6     public static void main(String[] args) throws OptionalDataException,
 7             IOException, ClassNotFoundException {
 8         long t1 = System.currentTimeMillis();
 9         Professor2 p = new Professor2("wangwu", 50);
10         Student2 s1 = new Student2("zhangsan", 18, p);
11         Student2 s2 = (Student2) s1.deepClone();
12         s2.p.name = "lisi";
13         s2.p.age = 30;
14         System.out.println("name=" + s1.p.name + "," + "age=" + s1.p.age); // 学生1的教授不改变。
15         long t2 = System.currentTimeMillis();
16         System.out.println(t2-t1);
17     }
18  
19 }

要想序列化对象，必须先创建一个OutputStream，然后把它嵌入ObjectOutputStream。这时就能用writeObject()方法把对象写入OutputStream。读的时候需要把InputStream嵌到ObjectInputStream中，然后再调用readObject()方法。不过这样读出来的只是一个Object的reference，因此，在用之前，还要下转型。

对象序列化不仅能保存对象的副本，而且会跟着对象中的reference把它所引用的对象也保存起来，然后再继续跟踪那些对象的reference，以此类推。这种情形常被称作”单个对象所联结的‘对象网’ “。

但是串行化却很耗时，在一些框架中，我们便可以感受到，它们往往将对象进行串行化后进行传递，耗时较多。

本篇文章来源于两位前辈的博文，以及《java程序员面试宝典》。为了表示对他人劳动成果的尊重，这里标注出处：

http://www.cnblogs.com/shuaiwhu/archive/2010/12/14/2065088.html
http://www.cnblogs.com/o-andy-o/archive/2012/04/06/2434904.html

Java中支持深浅拷贝的第三方库

最近项目上用到了一些Deep Clone的库，但是原来使用的库速度略慢，直接拖累了应用。

今天有空看了一下相关的可用的第三方库。

深拷贝

Apache旗下的Commons-Lang3包有一个序列化的工具SerializationUtils，可以做深拷贝。

当然前提是你的类实现了序列化接口。

Java Deep Cloning Library是我觉得最好用的一个。它的深拷贝通过反射实现，适合用于你
不能控制的第三方类或者没有实现序列化的类。

浅拷贝

还是Apache旗下，不过不是Commons-Lang3，而是Commons-Beanutils。其中BeanUtils提供了一个cloneBean方法。
可以直接简单的操作。

如果项目依赖了Spring的库，那么直接使用BeanUtils即可。