引用clone 浅clone 深clone 利用序列化clone 利用反射深clone

最新推荐文章于 2021-02-24 18:11:00 发布
最新推荐文章于 2021-02-24 18:11:00 发布
阅读量1.1k 收藏
点赞数
分类专栏： java 文章标签： string object class exception null byte
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clam_clam/article/details/6835129
版权

java 拷贝问题有3种情况：
先看如下代码：

package com;
class Address implements Cloneable{
	String city;
	Address(String city){
		this.city=city;
	}
	public String getCity() {
		return city;
	}

	@Override
	public String toString() {
		return "Address [city=" + city + "]";
	}
	public void setCity(String city) {
		this.city = city;
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}
public class Employee implements Cloneable{
	String name;
	int salary;
	Address addr;
	public Employee(String name,int salary,Address city){
		this.name=name;
		this.salary=salary;
		this.addr=city;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Address getAddr() {
		return addr;
	}
	public void setAddr(Address addr) {
		this.addr = addr;
	}
	@Override
	public String toString() {
		return "Employee [addr=" + addr + ", name=" + name + ", salary="
				+ salary + "]";
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Employee cloned=(Employee)super.clone();
		return cloned;
	}
	public static void main(String[] args) throws CloneNotSupportedException{ //
		 Employee e1=new Employee("李",500,new Address("北京")); //Employee是一个自定义类      
		 Employee e2=e1; //赋值对象      
		 e2.setName("王");//改变对象e2的名字 
		 e2.setSalary(1000);
		 e2.setAddr(new Address("上海"));
		 System.out.println("e1:"+e1); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]     
		 System.out.println("e2:"+e1); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]
		 System.out.println("e1.getAddr()==e2.getAddr():"+(e1.getAddr()==e2.getAddr()));
		 System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
		 
		 Employee e12=new Employee("李",500,new Address("北京")); //Employee是一个自定义类   
		 Employee e22=(Employee)e12.clone(); //赋值对象   
		 e22.setName("王");//改变对象e2的名字   
		 e22.setSalary(1000);
		 e22.setAddr(new Address("上海"));
		 System.out.println("e12:"+e12); //打印e1的结果: Employee [addr=Address [city=北京], name=李, salary=500]
		 System.out.println("e22:"+e22); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]
		 System.out.println("e12.getAddr()==e22.getAddr():"+(e12.getAddr()==e22.getAddr()));
		 System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
		 
		 Employee e13=new Employee("李",500,new Address("北京")); //Employee是一个自定义类   
		 Employee e23=(Employee)e13.clone(); //赋值对象   
		 e23.setName("王");//改变对象e2的名字   
		 e23.setSalary(1000);
		 e23.getAddr().setCity("上海");		 
		 System.out.println("e13:"+e13); //打印e1的结果: Employee [addr=Address [city=上海], name=李, salary=500]
		 System.out.println("e23:"+e23); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]
		 System.out.println("e13.getAddr()==e23.getAddr():"+(e13.getAddr()==e23.getAddr()));
	 }
}

1.引用拷贝 
 Employee e2=e1; //赋值对象      
		 e2.setName("王");//改变对象e2的名字 
		 e2.setSalary(1000);
		 e2.setAddr(new Address("上海"));
		 System.out.println("e1:"+e1); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]     
		 System.out.println("e2:"+e1); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]
		 System.out.println("e1.getAddr()==e2.getAddr():"+(e1.getAddr()==e2.getAddr()));//true
e1和e2指向同一对象：
执行结果为： 
e1:Employee [addr=Address [city=上海], name=王, salary=1000]
e2:Employee [addr=Address [city=上海], name=王, salary=1000]
e1.getAddr()==e2.getAddr():true

2.浅拷贝： 
 Employee e13=new Employee("李",500,new Address("北京")); //Employee是一个自定义类   
		 Employee e23=(Employee)e13.clone(); //赋值对象   
		 e23.setName("王");//改变对象e2的名字   
		 e23.setSalary(1000);
		 e23.getAddr().setCity("上海");		 
		 System.out.println("e13:"+e13); //打印e1的结果: Employee [addr=Address [city=上海], name=李, salary=500]
		 System.out.println("e23:"+e23); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]
		 System.out.println("e13.getAddr()==e23.getAddr():"+(e13.getAddr()==e23.getAddr()));//true

注意几点：
1）类必须实现接口，不然调用clone ()方法，运行时会报出CloneNotSupportedExceptio异常。
2） Object的clone() 是protected. 只能在包内或子类调用.
3） 如果浅克隆的对象中存在对象形式的成员变量，如上面的Addres。那么
Employee e23=(Employee)e13.clone(); //赋值对象   
只是拷贝了e13对象中的基本类型和不变量.可变的对象成员变量拷贝得到的仍然是引用.
如上打印的System.out.println("e13.getAddr()==e23.getAddr():"+(e13.getAddr()==e23.getAddr())); 为//true.
其中不可变量包括：a. String类对象 b. 被final定义,子对象在生存周期中仅保存一些常量。
4)对于程序段 
Employee e12=new Employee("李",500,new Address("北京")); //Employee是一个自定义类   
		 Employee e22=(Employee)e12.clone(); //赋值对象   
		 e22.setName("王");//改变对象e2的名字   
		 e22.setSalary(1000);
		 e22.setAddr(new Address("上海"));
		 System.out.println("e12:"+e12); //打印e1的结果: Employee [addr=Address [city=北京], name=李, salary=500]
		 System.out.println("e22:"+e22); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]
		 System.out.println("e12.getAddr()==e22.getAddr():"+(e12.getAddr()==e22.getAddr()));//false
		 System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

搞了好久，不是浅拷贝吗？怎么e12和e22指向同一地方呀。怎么 System.out.println("e12.getAddr()==e22.getAddr():"+(e12.getAddr()==e22.getAddr()));打印为false。
一下子被搞迷糊了，问了一下同学。原来拷贝的是Adress 是拷贝引用，但我后来把 e22 的Address 引用改了e22.setAddr(new Address("上海"));（注意是拷贝完改的肯定e12.getAddr()==e22.getAddr())就位false 了）。

3.深拷贝
我把上面Employee 类的clone 方法改一下。
如下代码： 
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Employee cloned=(Employee)super.clone();
		cloned.addr=(Address)addr.clone();
		return cloned;
	}

代码 
public static void main(String[] args) throws CloneNotSupportedException{ //
		 Employee e13=new Employee("李",500,new Address("北京")); //Employee是一个自定义类   
		 Employee e23=(Employee)e13.clone(); //赋值对象   
		 e23.setName("王");//改变对象e2的名字   
		 e23.setSalary(1000);
		 e23.getAddr().setCity("上海");		 
		 System.out.println("e13:"+e13); //打印e1的结果: Employee [addr=Address [city=北京], name=李, salary=500]
		 System.out.println("e23:"+e23); //打印e1的结果: Employee [addr=Address [city=上海], name=王, salary=1000]
		 System.out.println("e13.getAddr()==e23.getAddr():"+(e13.getAddr()==e23.getAddr()));
	 }
输出结果就为(深拷贝)： 
e13:Employee [addr=Address [city=北京], name=李, salary=500]
e23:Employee [addr=Address [city=上海], name=王, salary=1000]
e13.getAddr()==e23.getAddr():false
方法（四）使用序列化进行克隆

如下代码

package com;


import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


class Country implements Serializable{
	String coutry;
	Country (){
	}
}
class Address extends Country implements Serializable {
	String city;
	Address(String city,String country){
		this.city=city;
		this.coutry=country;
	}
	public String getCity() {
		return city;
	}


	@Override
	public String toString() {
		return "Address [city=" + city + ", coutry=" + coutry + "]";
	}
	public void setCity(String city) {
		this.city = city;
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}
class SerialCloneable implements Cloneable, Serializable
{  
   public Object clone()
   {  
      try
      {  
         // save the object to a byte array
         ByteArrayOutputStream bout = new 
            ByteArrayOutputStream();
         ObjectOutputStream out 
            = new ObjectOutputStream(bout);
         out.writeObject(this);
         System.out.println("bout.size:"+bout.size());//测试一下静态变量是否序列化，发现有没有静态变量打印结果是一样的。
         out.close();
         // read a clone of the object from the byte array
         ByteArrayInputStream bin = new 
            ByteArrayInputStream(bout.toByteArray());
         ObjectInputStream in = new ObjectInputStream(bin);
         Object ret = in.readObject();
         in.close();
         return ret;
      }  
      catch (Exception e)
      {  
         e.printStackTrace();
         return null;
      }
   }
}
public class Employee extends SerialCloneable{
	//public static int experience=10;
	String name;
	transient int salary;
	Address addr;


	public Employee(String name,int salary,Address city){
		this.name=name;
		this.salary=salary;
		this.addr=city;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Address getAddr() {
		return addr;
	}
	public void setAddr(Address addr) {
		this.addr = addr;
	}
	@Override
	public String toString() {
		/*return "Employee [addr=" + addr + ", name=" + name + ", salary="
				+ salary +",experience="+this.experience+"]";*/
		return "Employee [addr=" + addr + ", name=" + name + ", salary="
		+ salary +"]";
	}
	@Override
	public Object clone() {
		return super.clone();
	}
	public static void main(String[] args) throws CloneNotSupportedException{ //
		 Employee e13=new Employee("李",500,new Address("北京","中国")); //Employee是一个自定义类   
		 Employee e23=(Employee)e13.clone(); //赋值对象  
		 System.out.println("e13:"+e13); //打印e1的结果: Employee Employee [addr=Address [city=北京], name=李, salary=500]
		 System.out.println("e23:"+e23); //打印e1的结果:  Employee Employee [addr=Address [city=北京], name=李, salary=500]
		 System.out.println("e13.getAddr()==e23.getAddr():"+(e13.getAddr()==e23.getAddr()));
	 }
}

运行结果为： 
bout.size:222//不管//public static int experience=10; 有没有被注释掉打印的都是222 说明static 变量不会被序列化。
e13:Employee [addr=Address [city=北京, coutry=中国], name=李, salary=500]
e23:Employee [addr=Address [city=北京, coutry=中国], name=李, salary=0] salary =0 说明：transient 变量不会被序列化。
e13.getAddr()==e23.getAddr():false
1.注意开始时Address 类时这样写的。 
class Address{
......
}
结果报出：
java.io.NotSerializableException: com.Address异常。

最后改为class Address implements Serializable就可以了。所以使用序列话进行clone 的话，所以成员对象对应的类都应该实现Serializable接口。
2.如果 Country 不实现implements Serializable 不会报上面的错但 不会序列化。

class Country {
	String coutry;
	Country (){
	}
}
从输出结果可以看出： 
bout.size:179
e13:Employee [addr=Address [city=北京, coutry=中国], name=李我们, salary=500]
e23:Employee [addr=Address [city=北京, coutry=null], name=李我们, salary=0]//country=null; 说明没有序列化。如果父类没有实现Serializable接//口父类不会被序列化。
e13.getAddr()==e23.getAddr():false

方法（五）利用反射进行克隆
对一个对象进行复制有二种比较好的方式，一种就是序列化，另一种就是克隆。使用序列化进行复制很方便，因为此种方式会自动进行深层复制，只需要我们将要序列化的对象所 对应的类实现序列化标示性接口Serializable，它就会将对象里所引用的其他对象一并复制，但此种效率不及Object里的clone克隆方法。不过使用 clone进行克隆却是浅复制，它不会自动将对象里所引用的其他对象进行 深层克隆，所以如果我们想要进行深层复制时，需要覆写Object中的clone方法，对需要进行深层复制的域进行单独处理，所以应用起来比较麻烦，正是因为这样繁琐，下面我采用了 反射的方式来进行深层克隆clone，其只需要克隆的类继承该类DeepClone即可。
参考博客  http://www.iteye.com/topic/659877#1484197 。(写得很好)





缤纷的书签
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java利用序列化实现对象深度clone的方法
09-03
主要介绍了Java利用序列化实现对象深度clone的方法,实例分析了java序列化及对象克隆的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
新建对象：反射会调用构造函数，clone不会调用构造函数
weixin_30492047的博客
03-21 472
class Ins implements java.lang.Cloneable { public Ins() { System.out.println("Construct called"); } @Override public Ins clone() throws CloneNotSupportedException { ...
Java中clone( )和new效率比较
iblade的博客
06-20 1万+
对象创建的几种方法:1.使用new关键字2.使用clone方法3.反射机制4.反序列化以上四种都可以产生java对象1,3都会明确的显式的调用构造函数2是在内存上对已有对象的影印 所以不会调用构造函数4是从文件中还原类的对象 也不会调用构造函数clone和new那更快？直接上代码测试：package com.miivii.javalib; /** * Created by ylWang on ...
java 反射深度克隆_反射实现java深度克隆
weixin_32075745的博客
02-13 321
一、克隆有时想得到对象的一个复制品，该复制品的实体是原对象实体的克隆。复制品实体的变化不会引起原对象实体发生变化，这样的复制品称为原对象实体的克隆对象或简称克隆。1、浅复制(浅克隆)概念：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。方法：类implements Cloneable，然后重写c...
java 反射深度克隆_C#使用反射(Reflection)实现深复制与浅复制
weixin_39935777的博客
02-24 91
原文路径：https://blog.csdn.net/qq_28839293/article/details/794872941、浅复制：class Program{public static void Main(string[] args){var classA1 = new ClassA{a = 1,b = "haha",d = new ClassB{ c ="haha" }};var cla...
C#浅拷贝（MemberwiseClone等多种方法）与深拷贝（反射、多种反序列化）实例
03-26
（抱歉，我无法修改下载积分，本想着免积分的）C#浅拷贝（MemberwiseClone等多种方法）与深拷贝（反射、多种反序列化）实例
详解java中的深拷贝和浅拷贝（clone()方法的重写、使用序列化实现真正的深拷贝）
08-26
主要介绍了java中的深拷贝和浅拷贝（clone()方法的重写、使用序列化实现真正的深拷贝），文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C#中序列化实现深拷贝,实现DataGridView初始化刷新的方法
01-20
1.目标对需要序列化，并实现ICloneable 接口： [Serializable] public class DtoColumn : ICloneable2.实现接口方法Clone： public object Clone() { using (MemoryStream ms = new MemoryStream(capacity))
JAVA_高级特性（hashCode,clone,比较器，Class反射，序列化）
09-27
总结非常完全的文档。对Java初学着和进阶学习的学者是一份相当不错的Java学习资料
java 克隆_Java克隆(Clone)的应用
weixin_34749048的博客
02-12 305
Java克隆(Clone)的应用简介：Java克隆(Clone)是Java语言的特性之一，但在实际中应用比较少见。但有时候用克隆会更方便更有效率。对于克隆(Clone)，Java有一些限制：1、被克隆的类必须自己实现Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。Cloneable 接口实际上是个标识接口，没有任何接口方法。2、实现Clone...
第11条：谨慎地覆盖clone
凹凸曼哒小乖兽
11-18 1118
第11条：谨慎地覆盖clone    Cloneable接口的目的是作为对象的一个mixin接口，这表明这样的对象允许克隆(clone)。遗憾的是，它并没有成功地达到这个目的。其主要的缺陷在于，缺少一个clone方法，object的clone方法是受保护的。如果不借助于反射(reflection)，就不能仅仅因为一个对象实现了Clonable接口，就可以调用clone方法。即使是反射的调用也可能失败
二叉树的遍历 递归非递归 思路和 java实现
热门推荐
clam_clam的专栏
10-05 3万+
二叉树遍历首先弄清遍历流程。 中序遍历:第一次经过从它找左，第二次经过找右，第三次经过回来。第二次经过访问它。 算法实现： 第二次访问是 pop（&S,&p）;Visit（p->data）;因为中序遍历跟第三次经过没关系。所以第二次就弹出栈了。 Java版的程序如下： package com.tree; import java.util.Stack; public cla
谈谈 java 的protected 访问权限。
clam_clam的专栏
07-28 1万+
今天做项目时遇到一个问题。以为对同一包内的一个类调用另一个类的protected 方法感到很奇怪。然以为protected 需要派生类才能访问，没想到在同一包内也能访问protected 成员。哎！弄了 好久才明白。我的测试代码：基类代码：包为com.fupackage com.
统计String字符串中各字符个数
clam_clam的专栏
09-24 1万+
随便一个字符串里里面有中文英文各种符号怎么统计各字符的出现的个数。 package com; import java.util.HashMap; import java.util.Map; public class Test { public static void
Java静态初始化，实例初始化以及构造方法
clam_clam的专栏
08-15 8258
首先有三个概念需要了解： 一．静态初始化：是指执行静态初始化块里面的内容。 二．实例初始化：是指执行实例初始化块里面的内容。 三．构造方法：一个名称跟类的名称一样的方法，特殊在于不带返回值。 我们先来看一段程序结果： package com; class Book
IE 下 js文件 中文乱码解决
clam_clam的专栏
08-21 6565
IE 下 js 文件经常出现乱码。 1. js 和所在jsp 编码格式应该是一样的。 不仅pageEnding 一样，charset 也应该一样。 如我的JSP 头部设置为如下： <%@page language="java" pageEncoding="GBK" c
浅谈为什么Java接口中不允许定义变量
clam_clam的专栏
07-20 3501
接口就是提供一种统一的“协议”，而接口中的属性也属于“协议”中的成员。它们是公共的，静态的，最终的常量。相当于全局常量。抽象类是不“完全”的类，相当于是接口和具体类的一个中间层。即满足接口的抽象，也满足具体的实现。　　如果接口可以定义变量，但是接口中的方法又都是抽象的，在接口中无
传值还是传引用(1) — java
clam_clam的专栏
07-22 3174
发觉这篇文章讲的挺好的转过来了，顺便自己总结了一下。 By value or by reference 1. Object Copy Copy a object in javais dangerous.  If simply using =, it isshallow
在java里分别用new、反射、clone、反序列化四种方式产生对象
最新发布
03-31
1. 使用new关键字创建对象： ...4. 使用反序列化创建对象： ``` ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.ser")); Person p5 = (Person) in.readObject(); ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值