如何正确运用 JAVA的Clone(浅克隆与深克隆)

如何正确运用 JAVA的Clone(浅克隆与深克隆)
当我们运用java的clone机制的时候 一定要结合实际需求合理运用，日前遇到一个关于clone的问题， 描述如下：



问题是这样的：

当我们需要修改A对象的属性值， 却又想保留原有的A对象的一切， 这个时候我们会想到Clone。于是我们就调用了他的Clone方法（java.lang,Object的clone（））。 但是这种clone是浅克隆。也就是说他只克隆当前的A对象里面的基本类型的对象和引用对象这个引用值， 对于引用对象所指向的对象没有在进行clone。 如上图。 这样要是code里面有需求 去修改clone对象里面 引用所指向的元素的值，如Array，List， Map等 vals[index] = n, map.put("key",
value), list.remove(index) 诸如此类的修改操作。都会影响到被Clone的对象A。 看上图一目了然。

理论上我们需要实现java.lang.Cloneable, override的Clone()方法，把所有的引用对象 及其引用对象的子对象(直到最基本的对象类型) 都clone一边。这样是最保险的。 但是，有的时候结合实际需求，只深clone那些 可能会被修改的元素，那些完全没有可能和不允许修改的（只读的）引用对象，可以不必也进行深克隆。这样简化复杂度。

比如上图例子，如果List<List>所引用的对象不会有被修改的可能，那么我们可以不必遍历list的每一个对象进行clone。如果Map所引用的对象，它的键值对里面的value可能会被修改， 那么我们需要clone这个map的所有子元素 去构建一个新的Map。

简单实验：

CODE：

public class TestHashMapClone {

public static void main(String[] args) {

//HashMap has overrided clone()

HashMap source = new HashMap();

source.put("key1","value1");

source.put("key2","value2");

for(Iterator keyItr = source.keySet().iterator();keyItr.hasNext();) {

Object key = keyItr.next();

System.out.println(key + " : "+source.get(key));

}

System.out.println("---------------- 1 ----------------");

Map targetMap = (HashMap)source.clone();

for(Iterator keyItr = targetMap.keySet().iterator();keyItr.hasNext();){

Object key = keyItr.next();

System.out.println(key + " : "+source.get(key));

}

System.out.println("---------------- 2 ----------------");

Map targetMap1 = (HashMap)source.clone();

Object temp = targetMap1.put("key1","modify");

System.out.println("temp : "+temp);

for(Iterator keyItr = source.keySet().iterator();keyItr.hasNext();){

Object key = keyItr.next();

System.out.println(key + " : "+source.get(key));

}

System.out.println("---------------- 3 ----------------");

HashMap source1 = new HashMap();

source1.put("key1","value1");

source1.put("key2","value2");

Map targetMap2 = (HashMap)source1.clone();

Object temp2 = source1.put("key1","modify");

System.out.println("temp : "+temp2);

for(Iterator keyItr = targetMap2.keySet().iterator();keyItr.hasNext();){

Object key = keyItr.next();

System.out.println(key + " : "+targetMap2.get(key));

}

System.out.println("---------------- 4 ----------------");

HashMap source2 = new HashMap();

List list1 = new ArrayList<String>();

list1.add("value1");

list1.add("value2");

list1.add("value3");

List list2 = new ArrayList<String>();

list2.add("value1");

list2.add("value2");

list2.add("value3");

source2.put("key1",list1);

source2.put("key2",list2);

Map targetMap3 = (HashMap)source2.clone();

list1.set(0, "modify0");

System.out.println();

for(Iterator keyItr = source2.keySet().iterator();keyItr.hasNext();){

Object key = keyItr.next();

List<String> list = (List<String>)source2.get(key);

for(String value : list) {

System.out.println(key + " : "+ value);

}

}

System.out.println();

for(Iterator keyItr = targetMap3.keySet().iterator();keyItr.hasNext();){

Object key = keyItr.next();

List<String> list = (List<String>)targetMap3.get(key);

for(String value : list) {

System.out.println(key + " : "+ value);

}

}

}

}

实验结果：

key2 : value2

key1 : value1

---------------- 1 ----------------

key2 : value2

key1 : value1

---------------- 2 ----------------

temp : value1

key2 : value2

key1 : value1

---------------- 3 ----------------

temp : value1

key2 : value2

key1 : value1

---------------- 4 ----------------

key2 : value1

key2 : value2

key2 : value3

key1 : modify0

key1 : value2

key1 : value3

key2 : value1

key2 : value2

key2 : value3

key1 : modify0

key1 : value2

key1 : value3

总结：

注意如下几点即可：

a． 什么时候使用shallow Clone，什么时候使用deep Clone，这个主要看具体对象的域是什么性质的，基本型别还是reference variable ，以及实际的需求。

b． 调用Clone()方法的对象所属的类(Class)必须implements Cloneable接口，否则在调用Clone方法的时候会抛出CloneNotSupportedException。

c. 一般集合类都是浅clone，这个可以看一下他的源码。

【以下内容转载自：http://lovelace.iteye.com/blog/182772】

Java语言的一个优点就是取消了指针的概念，但也导致了许多程序员在编程中常常忽略了对象与引用的区别，特别是先学c、c++后学java的程序员。并且由于Java不能通过简单的赋值来解决对象复制的问题，在开发过程中，也常常要要应用clone（）方法来复制对象。比如函数参数类型是自定义的类时，此时便是引用传递而不是值传递。以下是一个小例子：

Java代码


public class A {
public String name;
}

Java代码


public class testClone {

public void changeA(A a){
a.name="b";
}
public void changInt(int i){
i=i*2+100;
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
testClone test=new testClone();
A a=new A();
a.name="a";
System.out.println("before change : a.name="+a.name);
test.changeA(a);
System.out.println("after change : a.name="+a.name);
int i=1;
System.out.println("before change : i="+i);
test.changInt(i);
System.out.println("after change : i="+i);
}

}

此时输出的结果是：

Java代码


before change : a.name=a
after change : a.name=b
before change : i=1
after change : i=1

从这个例子知道Java对对象和基本的数据类型的处理是不一样的。在Java中用对象的作为入口参数的传递则缺省为"引用传递"，也就是说仅仅传递了对象的一个"引用"，这个"引用"的概念同C语言中的指针引用是一样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操作。

除了在函数传值的时候是"引用传递"，在任何用"＝"向对象变量赋值的时候都是"引用传递"，如：

Java代码


A a1=new A();
A a2=new A();
a1.name="a1";
a2=a1;
a2.name="a2";
System.out.println("a1.name="+a1.name);
System.out.println("a2.name="+a2.name);

此时输出的结果是：

Java代码


a1.name=a2
a2.name=a2

如果我们要用a2保存a1对象的数据，但又不希望a2对象数据被改变时不影响到a1。实现clone（）方法是其一种最简单，也是最高效的手段。

下面我们来实现A的clone方法

Java代码


public class A implements Cloneable {
public String name;

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

}

首先要实现Cloneable接口，然后在重载clone方法，最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或间接调用了java.lang.Object类的clone()方法。

Java代码


A a1=new A();
A a2=new A();
a1.name="a1";
a2=a1;
a2.name="a2";
System.out.println("a1.name="+a1.name);
System.out.println("a2.name="+a2.name);

此时输出的结果是：

Java代码


a1.name=a1
a2.name=a2

当Class A成员变量类型是java的基本类型时（外加String类型）,只要实现如上简单的clone（称影子clone）就可以。但是如果Class A成员变量是数组或复杂类型时，就必须实现深度clone。

Java代码


public class A implements Cloneable {
public String name[];

public A(){
name=new String[2];
}

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

测试代码

Java代码


A a1=new A();
A a2=new A();
a1.name[0]="a";
a1.name[1]="1";
a2=(A)a1.clone();
a2.name[0]="b";
a2.name[1]="1";
System.out.println("a1.name="+a1.name);
System.out.println("a1.name="+a1.name[0]+a1.name[1]);
System.out.println("a2.name="+a2.name);
System.out.println("a2.name="+a2.name[0]+a2.name[1]);

输出结果：

Java代码


a1.name=[Ljava.lang.String;@757aef
a1.name=b1
a2.name=[Ljava.lang.String;@757aef
a2.name=b1

看到了吧，a1.name,a2.name的hash值都是@757aef,也就是说影子clone对name数组只是clone他们的地址！解决该办法是进行深度clone。

Java代码


public Object clone() {
A o = null;
try {
o = (A) super.clone();
o.name=(String[])name.clone();//其实也很简单^_^
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}

此时输出结果是：

Java代码


a1.name=[Ljava.lang.String;@757aef
a1.name=a1
a2.name=[Ljava.lang.String;@d9f9c3
a2.name=b1

需要注意的是Class A存在更为复杂的成员变量时，如Vector等存储对象地址的容器时，就必须clone彻底。

Java代码


public class A implements Cloneable {
public String name[];
public Vector<B> claB;

public A(){
name=new String[2];
claB=new Vector<B>();
}

public Object clone() {
A o = null;
try {
o = (A) super.clone();
o.name==(String[])name.clone();//深度clone
o.claB=new Vector<B>();//将clone进行到底
for(int i=0;i<claB.size();i++){
B temp=(B)claB.get(i).clone();//当然Class B也要实现相应clone方法
o.claB.add(temp);
}
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}