首页 > > 程序设计 > Java技术 >

Java中的clone方法-理解浅拷贝和深拷贝

2018-06-18 02:56:55来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

最近学到Java虚拟机的相关知识，更加能理解clone方法的机制了

java中的我们常常需要复制的类型有三种：

1：8种基本类型，如int，long，float等；

2：复合数据类型（数组）；

3：对象变量。

基本数据类型存放在栈中；而对象实例和数组都在堆上分配。

对于基本数据类型我们不需要考虑浅拷贝和深拷贝，使用等号便可复制值。

对于复合数据类型使用等号浅拷贝，仅复制该字段值，如数组则复制地址。。对复合类型使用clone（）方法或者System.arrayCopy进行深拷贝（拷贝复合类型对象的时候，会为其重新创建对象）。

int num1=2;
int num2=num1;
num2=4;
System.out.println(num1==num2);
int[] a={2,1,4,3,5};
int[] b=a;
b[0]=8;
System.out.println(a==b);
int[] c={2,1,4,3,5};
int[] d=c.clone();
d[0]=8;
System.out.println(c==d);

则上述输出为

false

true 
false

而对于对象变量，使用clone()仅能实现浅拷贝（仅复制对象的在栈中的reference），下面文章具体对对象变量的两种克隆进行分析。

 

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

复制对象 or 复制引用

在Java中，以下类似的代码非常常见：

Person p = new Person(23, "zhang");  
Person p1 = p;  
  
System.out.println(p);  
System.out.println(p1);

　　

当Person p1 = p;执行之后， 是创建了一个新的对象吗？ 首先看打印结果：
com.pansoft.zhangjg.testclone.Person@2f9ee1ac
com.pansoft.zhangjg.testclone.Person@2f9ee1ac
 
可已看出，打印的地址值是相同的，既然地址都是相同的，那么肯定是同一个对象。p和p1只是引用而已，他们都指向了一个相同的对象Person(23, "zhang") 。 可以把这种现象叫做引用的复制。上面代码执行完成之后， 内存中的情景如下图所示： 

而下面的代码是真真正正的克隆了一个对象。

Person p = new Person(23, "zhang");  
Person p1 = (Person) p.clone();  
  
System.out.println(p);  
System.out.println(p1);

　　

从打印结果可以看出，两个对象的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量：
com.pansoft.zhangjg.testclone.Person@2f9ee1ac
com.pansoft.zhangjg.testclone.Person@67f1fba0
以上代码执行完成后， 内存中的情景如下图所示：
 

深拷贝 or 浅拷贝

 
上面的示例代码中，Person中有两个成员变量，分别是name和age， name是String类型， age是int类型。代码非常简单，如下所示：
public class Person implements Cloneable{  
      
    private int age ;  
    private String name;  
      
    public Person(int age, String name) {  
        this.age = age;  
        this.name = name;  
    }  
      
    public Person() {}  
  
    public int getAge() {  
        return age;  
    }  
  
    public String getName() {  
        return name;  
    }  
      
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        return (Person)super.clone();  
    }  
}

　　

由于age是基本数据类型， 那么对它的拷贝没有什么疑议，直接将一个4字节的整数值拷贝过来就行。但是name是String类型的， 它只是一个引用， 指向一个真正的String对象，那么对它的拷贝有两种方式： 直接将源对象中的name的引用值拷贝给新对象的name字段， 或者是根据原Person对象中的name指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的Person对象的name字段。这两种拷贝方式分别叫做浅拷贝和深拷贝。深拷贝和浅拷贝的原理如下图所示：
 
下面通过代码进行验证。如果两个Person对象的name的地址值相同， 说明两个对象的name都指向同一个String对象， 也就是浅拷贝， 而如果两个对象的name的地址值不同， 那么就说明指向不同的String对象， 也就是在拷贝Person对象的时候， 同时拷贝了name引用的String对象， 也就是深拷贝。验证代码如下：
Person p = new Person(23, "zhang");  
Person p1 = (Person) p.clone();  
  
String result = p.getName() == p1.getName()   
        ? "clone是浅拷贝的" : "clone是深拷贝的";  
  
System.out.println(result);

　　

打印结果为：

clone是浅拷贝的
 
所以，clone方法执行的是浅拷贝， 在编写程序时要注意这个细节。
 
 

覆盖Object中的clone方法， 实现深拷贝

 
现在为了要在clone对象时进行深拷贝， 那么就要Clonable接口，覆盖并实现clone方法，除了调用父类中的clone方法得到新的对象， 还要将该类中的引用变量也clone出来。如果只是用Object中默认的clone方法，是浅拷贝的，再次以下面的代码验证：
 
 1 static class Body implements Cloneable{  
 2     public Head head;  
 3       
 4     public Body() {}  
 5   
 6     public Body(Head head) {this.head = head;}  
 7   
 8     @Override  
 9     protected Object clone() throws CloneNotSupportedException {  
10         return super.clone();  
11     }  
12       
13 }  
14 static class Head /*implements Cloneable*/{  
15     public  Face face;  
16       
17     public Head() {}  
18     public Head(Face face){this.face = face;}  
19       
20 }   
21 public static void main(String[] args) throws CloneNotSupportedException {  
22       
23     Body body = new Body(new Head());  
24       
25     Body body1 = (Body) body.clone();  
26       
27     System.out.println("body == body1 : " + (body == body1) );  
28       
29     System.out.println("body.head == body1.head : " +  (body.head == body1.head));  
30       
31       
32 }
在以上代码中， 有两个主要的类， 分别为Body和Face， 在Body类中， 组合了一个Face对象。当对Body对象进行clone时， 它组合的Face对象只进行浅拷贝。打印结果可以验证该结论：
body == body1 : false
body.head == body1.head : true
 
如果要使Body对象在clone时进行深拷贝， 那么就要在Body的clone方法中，将源对象引用的Head对象也clone一份。
 1 static class Body implements Cloneable{  
 2     public Head head;  
 3     public Body() {}  
 4     public Body(Head head) {this.head = head;}  
 5   
 6     @Override  
 7     protected Object clone() throws CloneNotSupportedException {  
 8         Body newBody =  (Body) super.clone();  
 9         newBody.head = (Head) head.clone();  
10         return newBody;  
11     }  
12       
13 }  
14 static class Head implements Cloneable{  
15     public  Face face;  
16       
17     public Head() {}  
18     public Head(Face face){this.face = face;}  
19     @Override  
20     protected Object clone() throws CloneNotSupportedException {  
21         return super.clone();  
22     }  
23 }   
24 public static void main(String[] args) throws CloneNotSupportedException {  
25       
26     Body body = new Body(new Head());  
27       
28     Body body1 = (Body) body.clone();  
29       
30     System.out.println("body == body1 : " + (body == body1) );  
31       
32     System.out.println("body.head == body1.head : " +  (body.head == body1.head));  
33       
34       
35 }
打印结果为：
body == body1 : false
body.head == body1.head : false
 
由此可见， body和body1内的head引用指向了不同的Head对象， 也就是说在clone Body对象的同时， 也拷贝了它所引用的Head对象， 进行了深拷贝。
 
 

真的是深拷贝吗

 
由上一节的内容可以得出如下结论：如果想要深拷贝一个对象， 这个对象必须要实现Cloneable接口，实现clone方法，并且在clone方法内部，把该对象引用的其他对象也要clone一份 ， 这就要求这个被引用的对象必须也要实现Cloneable接口并且实现clone方法。
 
那么，按照上面的结论， Body类组合了Head类， 而Head类组合了Face类，要想深拷贝Body类，必须在Body类的clone方法中将Head类也要拷贝一份，但是在拷贝Head类时，默认执行的是浅拷贝，也就是说Head中组合的Face对象并不会被拷贝。验证代码如下：（这里本来只给出Face类的代码就可以了， 但是为了阅读起来具有连贯性，避免丢失上下文信息， 还是给出整个程序，整个程序也非常简短）
 1 static class Body implements Cloneable{  
 2     public Head head;  
 3     public Body() {}  
 4     public Body(Head head) {this.head = head;}  
 5   
 6     @Override  
 7     protected Object clone() throws CloneNotSupportedException {  
 8         Body newBody =  (Body) super.clone();  
 9         newBody.head = (Head) head.clone();  
10         return newBody;  
11     }  
12       
13 }  
14   
15 static class Head implements Cloneable{  
16     public  Face face;  
17       
18     public Head() {}  
19     public Head(Face face){this.face = face;}  
20     @Override  
21     protected Object clone() throws CloneNotSupportedException {  
22         return super.clone();  
23     }  
24 }   
25   
26 static class Face{}  
27   
28 public static void main(String[] args) throws CloneNotSupportedException {  
29       
30     Body body = new Body(new Head(new Face()));  
31       
32     Body body1 = (Body) body.clone();  
33       
34     System.out.println("body == body1 : " + (body == body1) );  
35       
36     System.out.println("body.head == body1.head : " +  (body.head == body1.head));  
37       
38     System.out.println("body.head.face == body1.head.face : " +  (body.head.face == body1.head.face));  
39       
40       
41 }
打印结果为：
body == body1 : false
body.head == body1.head : false
body.head.face == body1.head.face : true
 
内存结构图如下图所示：
 
那么，对Body对象来说，算是这算是深拷贝吗？其实应该算是深拷贝，因为对Body对象内所引用的其他对象（目前只有Head）都进行了拷贝，也就是说两个独立的Body对象内的head引用已经指向了独立的两个Head对象。但是，这对于两个Head对象来说，他们指向了同一个Face对象，这就说明，两个Body对象还是有一定的联系，并没有完全的独立。这应该说是一种不彻底的深拷贝。
 
 

如何进行彻底的深拷贝

 
对于上面的例子来说，怎样才能保证两个Body对象完全独立呢？只要在拷贝Head对象的时候，也将Face对象拷贝一份就可以了。这需要让Face类也实现Cloneable接口，实现clone方法，并且在在Head对象的clone方法中，拷贝它所引用的Face对象。修改的部分代码如下：
 1 static class Head implements Cloneable{  
 2     public  Face face;  
 3       
 4     public Head() {}  
 5     public Head(Face face){this.face = face;}  
 6     @Override  
 7     protected Object clone() throws CloneNotSupportedException {  
 8         //return super.clone();  
 9         Head newHead = (Head) super.clone();  
10         newHead.face = (Face) this.face.clone();  
11         return newHead;  
12     }  
13 }   
14   
15 static class Face implements Cloneable{  
16     @Override  
17     protected Object clone() throws CloneNotSupportedException {  
18         return super.clone();  
19     }  
20 }

写在最后

 
clone在平时项目的开发中可能用的不是很频繁，但是区分深拷贝和浅拷贝会让我们对java内存结构和运行方式有更深的了解。至于彻底深拷贝，几乎是不可能实现的。深拷贝和彻底深拷贝，在创建不可变对象时，可能对程序有着微妙的影响，可能会决定我们创建的不可变对象是不是真的不可变。clone的一个重要的应用也是用于不可变对象的创建。
 
本文转至http://blog.csdn.net/zhangjg_blog/article/details/18369201/

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：【原】无脑操作：IDEA + maven + SpringBoot + JPA + Thymeleaf

下一篇：使用Mac自带svn搭建服务器，并使用idea进行连接

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签