克隆的理解

最新推荐文章于 2019-08-07 16:08:08 发布
最新推荐文章于 2019-08-07 16:08:08 发布
阅读量1.6k 收藏
点赞数
分类专栏： Java 文章标签： 克隆 深克隆 浅克隆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tayanxunhua/article/details/20118999
版权
一、Cloneable 的用途  
Cloneable和Serializable一样都是标记型接口，它们内部都没有方法和属性，implements Cloneable表示该对象能被克隆，能使用Object.clone()方法。如果没有implements Cloneable的类调用Object.clone()方法就会抛出CloneNotSupportedException。

二、克隆的分类
1、浅克隆（ shallow clone ）
     拷贝对象的时候仅仅拷贝对象本身和对象中的基本变量，而不拷贝对象中包含的引用所指向的对象。
2、深克隆（ deep clone ）
     拷贝对象的时候不仅仅拷贝对象本身，同时拷贝对象所包含的的引用所指向的对象。
举例说明：
对象A1中包含对B1的引用，B1中包含对C1的引用。
浅拷贝A1得到A2，A2中依然包含对B1的引用，B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归，深拷贝A1得到A2，A2中包含对B2（B1的copy）的引用，B2中包含对C2（C1的copy）的引用。 

三、克隆的举例
要让一个对象进行克隆，其实就是两个步骤： 
       1、让类实现java.lang.Cloneable接口
      2、重写(override) Object类的clone()方法
代码实现：
package   com.tyxh.create;

public   class   Wife   implements   Cloneable {
      private   int   id ;
      private   String   name ;

      public   int   getId() {
             return   id ;
     }

      public   void   setId(   int   id) {
             this .   id   = id;
     }

      public   String getName() {
             return   name ;
     }

      public   void   setName(String name) {
             this .   name   = name;
     }

      public   Wife(   int   id,String name) {
             this .   id   = id;
             this .   name   = name;
     }

      @Override
      public   int   hashCode() {
             final   int   prime = 31;
             int   result = 1;
          result = prime * result +   id ;
          result = prime * result + ((   name   ==   null ) ? 0 :   name .hashCode());
             return   result;
     }
     
      @Override
      public   boolean   equals (Object obj) {
             if   (   this   == obj)
                 return   true ;
             if   (obj ==   null )
                 return   false ;
             if   (getClass() != obj.getClass())
                 return   false ;
          Wife other = (Wife) obj;
             if   (   id   != other.   id )
                 return   false ;
             if   (   name   ==   null ) {
                 if   (other.   name   !=   null )
                      return   false ;
          }   else   if   (!   name .equals(other.   name ))
                 return   false ;
             return   true ;
     }

      @Override
      public   Object clone()   throws   CloneNotSupportedException {
             return   super .clone();
     }

      public   static   void   main(String[] args)   throws   CloneNotSupportedException {
          Wife wife =   new   Wife(1,   "wang" );
          Wife wife2 =   null ;
          wife2 = (Wife) wife.clone();
          System.   out .println(   "wife  : "   + wife);
          System.   out .println(   "wife2 : "   + wife2);
          wife.setName(   "tyxh" );
          System.   out .println(   "wife  : "   + wife);
          System.   out .println(   "wife2 : "   + wife2);
          wife2.setName(   "sotaof" );
          System.   out .println(   "wife  : "   + wife);
          System.   out .println(   "wife2 : "   + wife2);
             //上面两个输出的地址相同，克隆的只是引用
          System.   out .println(   "class same=" +(wife.getClass()==wife2.getClass()));   //true
          System.   out .println(   "object same=" +(wife==wife2)); //false 说明两个对象的地址不同
          System.   out .println(   "object equals=" +(wife.equals (wife2))); //false
     }
}

输入结果：
wife  : com.tyxh.create.Wife@3795e3
wife2 : com.tyxh.create.Wife@3795e3
wife  : com.tyxh.create.Wife@369415
wife2 : com.tyxh.create.Wife@3795e3
wife  : com.tyxh.create.Wife@369415
wife2 : com.tyxh.create.Wife@ca8fb940
class same=true
object same=false
object equals=false

第一行和第二行相同的原因不是因为克隆后的wife和wife2地址相同，而是因为hashcode的缘故，我们注意hashcode的返回值 result = prime * result + ((  name  ==  null ) ? 0 :  name .hashCode());name变化的话，返回值就会发生改变。 如果你在hashcode方法中返回1，那么结果就会是@1；

当对wife的name值进行修改之后，wife的值变化了，而wife2的值没有变化；

当对wife2的name值进行修改之后， wife2的值变化了 ，而 wife的值没有变化 。

但是这并不代表wife和wife2的地址发生了改变，这仅仅能说明wife和wife2的值发生了改变。当我们注释掉hashCode()和equals()方法之后，再看一下输出结果：

wife  : com.tyxh.create.Wife@3771ed5e
wife2 : com.tyxh.create.Wife@1896d2c2
wife  : com.tyxh.create.Wife@3771ed5e
wife2 : com.tyxh.create.Wife@1896d2c2
wife  : com.tyxh.create.Wife@3771ed5e
wife2 : com.tyxh.create.Wife@1896d2c2
class same=true
object same=false
object equals=false
通过结果可以看出，不管是对wife还是对wife2进行值的修改，它们的地址都没有改变。

四.浅克隆的举例  
package   com.tyxh.create;

public   class   Husband   implements   Cloneable {
      private   int   id ;
      private   Wife   wife ;
     
      public   Wife getWife() {
             return   wife ;
     }

      public   void   setWife(Wife wife) {
             this .   wife   = wife;
     }

      public   int   getId() {
             return   id ;
     }

      public   void   setId(   int   id) {
             this .   id   = id;
     }

      public   Husband(   int   id) {
             this .   id   = id;
     }

      @Override
      public   int   hashCode() { 
             final   int   prime = 31;
             int   result = 1;
          result = prime * result +   id ;
             return   result;
     }

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

      @Override
      public   boolean   equals(Object obj) {
             if   (   this   == obj)
                 return   true ;
             if   (obj ==   null )
                 return   false ;
             if   (getClass() != obj.getClass())
                 return   false ;
          Husband other = (Husband) obj;
             if   (   id   != other.   id )
                 return   false ;
             return   true ;
     }

      /**
      *   @param   args
      *   @throws   CloneNotSupportedException
      */
      public   static   void   main(String[] args)   throws   CloneNotSupportedException {
          Wife wife =   new   Wife(1,   "jin" );
          Husband husband =   new   Husband(1);
          Husband husband2 =   null ;
          husband.setWife(wife);
          husband2 = (Husband) husband.clone();
          System.   out .println(   "husband  : "   + husband);
          System.   out .println(   "husband2 : "   + husband2);
          System.   out .println(   "husband class same=" +(husband.getClass()==husband2.getClass()));   //true
          System.   out .println(   "husband object same=" +(husband==husband2)); //false
          System.   out .println(   "husband object equals=" +(husband.equals(husband))); //true
          System.   out .println(   "wife class same=" +(husband.getWife().getClass()==husband2.getWife().getClass()));   //true
          System.   out .println(   "wife object same=" +(husband.getWife()==husband2.getWife()));   //true 说明引用是同一个引用
          System.   out .println(   "wife object equals=" +(husband.getWife().equals(husband.getWife())));   //true
     }
}

输入结果如下：
husband  : com.tyxh.create.Husband@20
husband2 : com.tyxh.create.Husband@20
husband class same=true
husband object same=false
husband object equals=true
wife class same=true
wife object same=true
wife object equals=true

四.深克隆的举例  
package   com.tyxh.create;

public   class   Husband   implements   Cloneable {
      private   int   id ;
      private   Wife   wife ;
     
      public   Wife getWife() {
             return   wife ;
     }

      public   void   setWife(Wife wife) {
             this .   wife   = wife;
     }

      public   int   getId() {
             return   id ;
     }

      public   void   setId(   int   id) {
             this .   id   = id;
     }

      public   Husband(   int   id) {
             this .   id   = id;
     }

      @Override
      public   int   hashCode() {   //myeclipse 自动生成的
             final   int   prime = 31;
             int   result = 1;
          result = prime * result +   id ;
             return   result;
     }

      @Override
      protected   Object clone()   throws   CloneNotSupportedException {
          Husband husband = (Husband)   super .clone();
          husband.   wife   = (Wife) husband.getWife().clone();
             return   husband;
     }

      @Override
      public   boolean   equals(Object obj) {   //myeclipse 自动生成的
             if   (   this   == obj)
                 return   true ;
             if   (obj ==   null )
                 return   false ;
             if   (getClass() != obj.getClass())
                 return   false ;
          Husband other = (Husband) obj;
             if   (   id   != other.   id )
                 return   false ;
             return   true ;
     }

      /**
      *   @param   args
      *   @throws   CloneNotSupportedException
      */
      public   static   void   main(String[] args)   throws   CloneNotSupportedException {
          Wife wife =   new   Wife(1,   "jin" );
          Husband husband =   new   Husband(1);
          Husband husband2 =   null ;
          husband.setWife(wife);
          husband2 = (Husband) husband.clone();
          System.   out .println(   "husband  : "   + husband);
          System.   out .println(   "husband2 : "   + husband2);
          System.   out .println(   "husband class same=" +(husband.getClass()==husband2.getClass()));   //true
          System.   out .println(   "husband object same=" +(husband==husband2)); //false
          System.   out .println(   "husband object equals=" +(husband.equals(husband))); //true
          System.   out .println(   "wife class same=" +(husband.getWife().getClass()==husband2.getWife().getClass()));   //true
          System.   out .println(   "wife object same=" +(husband.getWife()==husband2.getWife()));   //false 说明引用不是同一个引用
          System.   out .println(   "wife object equals=" +(husband.getWife().equals(husband.getWife())));   //true
     }
}

输出结果如下：
husband  : com.tyxh.create.Husband@20
husband2 : com.tyxh.create.Husband@20
husband class same=true
husband object same=false
husband object equals=true
wife class same=true
wife object same=false
wife object equals=true

五、通过反序列化克隆 （也是深克隆）
package   com.tyxh.create;

import   java.io.*;

public   class   BeanUtil {
      @SuppressWarnings (   "unchecked" )
      public   static   <T> T cloneTo(T src) {
          ByteArrayOutputStream memoryBuffer =   new   ByteArrayOutputStream();
          ObjectOutputStream out =   null ;
          ObjectInputStream in =   null ;
          T dist =   null ;
          
             try   {
              out =   new   ObjectOutputStream(memoryBuffer);
              out.writeObject(src);
              out.flush();
              
              in =   new   ObjectInputStream(   new   ByteArrayInputStream(memoryBuffer.toByteArray()));
              dist = (T) in.readObject();
              
          }   catch   (Exception e) {
              e.printStackTrace();
          }   finally   {
                 if (out !=   null ) {
                      try   {
                        out.close();
                   }   catch   (IOException e) {
                        e.printStackTrace();
                   }
              }
                 if (in !=   null ) {
                      try   {
                        in.close();
                   }   catch   (IOException e) {
                        e.printStackTrace();
                   }
              }
          }
                   
             return   dist;
     }
     
      public   static   void   main(String[] args) {
          Husband husband =   new   Husband(1);
          Wife wife =   new   Wife(1,   "jin" );
          husband.setWife(wife);
          Husband husband2 = cloneTo(husband);
          System.   out .println( "husband class same=" +(husband.getClass()==husband2.getClass()));   //true
          System.   out .println(   "husband object same=" +(husband==husband2)); //false
          System.   out .println( "husband object equals=" +(husband.equals(husband))); //true
          System.   out .println( "wife class same=" +(husband.getWife().getClass()==husband2.getWife().getClass()));   //true
          System.   out .println( "wife object same=" +(husband.getWife()==husband2.getWife()));   //false 说明引用不是同一个引用
          System.   out .println( "wife object equals=" +(husband.getWife().equals(husband.getWife())));   //true
     }
}

输出结果如下：
husband class same=true
husband object same=false
husband object equals=true
wife class same=true
wife object same=false
wife object equals=true

通过第二行可以看出，反序列化之后的husband2与husband不是同一个对象
通过第五行可以看出，反序列化属于一种深克隆，因为husband和husband2的wife对象不同


踏雁寻花
关注
专栏目录
对JAVA克隆机制的理解
积极向上的老王诩
05-16 255
Cloneable接口是一个标记接口,也就是没有任何内容。clone方法是在Object中定义的，而且是protected型的，只有实现了这个接口，才可以在该类的实例上调用clone方法，否则会抛出CloneNotSupportException。 Object提供了一个对象拷贝的默认方法clone方法，但是该方法是有缺陷的，它提供了一种浅拷贝方式，也就是它并不会把对象所有属性全部拷贝一份，而是...
简单理解浅克隆和深克隆
有一只柴犬的专栏
03-01 486
定义 浅克隆（Shadow Clone）： 拷贝对象时仅仅拷贝对象本身，而不拷贝对象包含的引用指向的对象；对于数据类型是基本数据类型的成员变量，会直接进行值传递，也就是将该属性值复制一份给新的对象。 深克隆（Deep Clone）： 将原型对象中所有类型，无论是值类型还是引用类型，都复制一份给克隆对象。 浅克隆的实现： import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @Dat
白话简单克隆和深度克隆
老紫竹的专栏
10-04 3722
一个羊圈，里面有一群羊。简单克隆：你重新建了一个羊圈，然后把那群羊圈进去，此时有2个羊圈，但里面是相同的一群羊。深度克隆：你重新建了一个羊圈，然后把每只羊也克隆了一份(医学技术高啊）,此时有2个羊圈，且有2群羊。每只羊在另一个圈里都有一个完全相同的羊。如果能把草地、地球都克隆了，就更强了。
Java中深克隆与浅克隆的简单理解
chenlei117的专栏
03-12 611
其实深克隆跟浅克隆没有太大的区别，只是概念和叫法不一样， 相同点：实现Cloneable接口，重写clone方法，注意和重载的区别，可参考JAVA的重载、覆盖和隐藏的区别一文 为什么会有深克隆呢，其实是因为克隆的时候，java虚拟机只clone了基本数据类型和sting类型(注意String类型不是基本数据类型，它也没有实现clone方法)，对于引用类型的成员，它没有处理。哪些是引用类
第十一条：简单理解clone
麦子专栏
10-18 315
package cn.stu; public class Student implements Cloneable{ public String name; public String school; @Override protected Object clone() throws CloneNotSupportedException { St
深入理解Java中的克隆
09-01
要正确地实现克隆，需要理解浅拷贝和深拷贝的区别，并根据需求选择合适的复制策略。同时，需要注意`Cloneable`接口的使用以及`clone()`方法的重写，以避免`CloneNotSupportedException`异常。在处理包含可变引用类型...
深入理解Xen虚拟机克隆复制实战
09-30
Xen虚拟机克隆实战是关于如何利用Xen虚拟化技术以及virt-clone命令来复制或克隆虚拟机的技术文章。本文档详细介绍了在Xen环境中克隆虚拟机的步骤和注意事项，包括确保克隆前虚拟机的状态，以及克隆后如何调整网络...
基于深度学习的中英文声音克隆系统
05-05
在这个系统中，人工智能体现在让计算机理解、模仿和生成与人类声音相似的音频。 “语音克隆”和“语音复制”是指通过技术手段复制一个人的语音特性，如音色、语速、语调等，使得生成的语音听起来像是原人发声。这一...
网页克隆器（源代码下载）.zip
07-14
通过分析这个“网页克隆器”的源代码，开发者可以了解到如何构建这样的工具，学习网络请求、HTML解析、资源下载等技术，也可以对软件架构和设计模式有更深入的理解。同时，源代码分析还能提供一个实战练习，提升编程...
java 对象的克隆（浅克隆和深克隆）
08-29
Java对象的克隆是编程中一个重要的概念，主要用于创建一个对象的新副本，这个副本与原对象具有相同的属性值。在Java中，有两种主要的克隆方式...理解这两种克隆方式对于处理复杂的对象结构和避免数据共享问题至关重要。
java克隆理解
何处安放
02-19 309
克隆的实现方式： 1.实现Cloneable接口并重写Object类中的clone()方法； package com.example.demo.ee.test; public class User implements Cloneable{   private String name;   private Integer age;      public User(String name,...
深复制 浅复制简单理解
yilukuangpao的博客
12-25 285
深复制 浅复制简单理解
简单理解深度克隆对象
撒野
08-07 722
要了解什么是深度克隆对象，首先要知道什么是深拷贝。深拷贝指的是修改克隆出来的对象不会改变原始的对象，基本数据类型的拷贝都是深拷贝。如下代码 var str = 'a'; var str1 = str; str1 = '123'; console.log(str);//a 没有修改原始对象（str），所以是深拷贝 除了深拷贝，还有浅拷贝，浅拷贝的特点是修改克隆对象会改变原始对象。如下代码。 va...
1.1.基本
LongYY的博客
11-02 181
1.&amp;和&amp;&amp;区别 &amp;和&amp;&amp;都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。 &amp;&amp;还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null &amp;&amp;...
彻底理解克隆、深拷贝和浅拷贝（俩种方法）
编程爱好者
09-01 5638
之前在学Javase时没注意到克隆这个方法，后面再网上看博客和面试题是经常看到克隆、深拷贝和浅拷贝这些词语，刚开始看被吓一跳，以为有多复杂，今天下决心给他搞明白，突然发现原来这么简单，给以后的自己一个警醒，往往认为难的其实也没什么，一定要克服心理关。 首先理解克隆： 我们正常复制一个引用类型的数据时，会直接用赋值符号进行赋值，而这种赋值方法其实俩者共用的还是同一个对象，通过其中一个来改变对象中...
彻底理解Java深克隆和浅克隆的原理及实现
lovezhaohaimig的博客
05-19 3万+
一、为什么要克隆？答案是：克隆的对象可能包含一些已经修改过的属性,保留着你想克隆对象的值，而new出来的对象的属性全是一个新的对象，对应的属性没有值，所以我们还要重新给这个对象赋值。即当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发现了clone是一个nat...
eclipse报错：Failed to load the JNI shared library
热门推荐
踏雁寻花
07-27 4万+
电脑自装系统以来，好久没有写java代码了，所以一直也没用eclipse IDE，今天将eclipse打开，报了个问题，Failed to load the JNI shared library，最初以为是jdk的问题呢，就重新安装了jdk1.7，配置了一下环境变量，结果还是报同样的错误，后来仔细一看错误的原因，上图： 错误还有如下信息："d:\DevSuiteHome_1\jdk\jre\b
Vector和ArrayList的比较
踏雁寻花
08-18 2万+
今天研究了一下Vector和ArrayList的源码，又加深了对这两个类的理解。 List接口下一共实现了三个类：ArrayList，Vector，LinkedList。LinkedList就不多说了，它一般主要用在保持数据的插入顺序的时候。ArrayList和Vector都是用数组实现的，主要有这么三个区别： 1、Vector是多线程安全的，而ArrayList不是，这个可以从源码中看出，V
JavaBean是什么
踏雁寻花
02-24 1万+
JavaBean是一种特殊的Java类，即：有默认构造方法，只有get和set方法的java类的对象。 专业解释：软件组件就是指可以进行独立分离、易于重复使用的软件部分。JavaBean就是一种基于Java平台的软件组件思想，JavaBean也是一种独立于平台和结构的应用程序编程接口（API）。JavaBean保留了其他软件组件的技术精华，并添加了被其他软件组件技术忽略的技术特性，使得它
JavaScript浅深克隆理解与实现
"JavaScript浅层克隆与深度克隆的概念、区别及实现方式" ...通过深入理解JavaScript的浅层克隆和深度克隆，开发者可以更好地管理数据状态，避免因意外修改导致的错误，提高代码的健壮性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值