也谈java浅克隆与深克隆

最新推荐文章于 2024-02-28 00:59:57 发布
最新推荐文章于 2024-02-28 00:59:57 发布
阅读量4k 收藏 10
点赞数 6
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhutulang/article/details/48163213
版权

如果我们有一个对象a，我们想得到它的一个克隆，那么我们该怎么做呢？最直观、最笨的方法是我们先new一个a的同类对象b，然后挨个拷贝a的属性给b中的相应属性。那么，这里马上就得引出两个概念：浅克隆与深克隆。

如果用直白的、非严格定义的语言来解释这两个概念，那么可以这么说：

所谓浅克隆是指复制一个对象的实例，但是这个对象中包含的其它的对象还是共用的。

所谓深克隆是指复制一个对象的实例，而且这个对象中包含的其它的对象也要复制一份。

如果我们要深克隆一个对象，而这个对象又比较复杂，它还包含n多其它对象的引用，那么要用我们开始说的那种克隆方法，简直是要人命! 即便是我们只要一个浅克隆的对象，如果这个对象有几十上百个基本属性，我们挨个去复制也是不可接受的！

那么，我们先来看看java中浅克隆一个对象可以怎么做。

Object 类提供有一个clone方法，它的方法签名如下：

 protected native Object clone() throws CloneNotSupportedException;

可以看到：（1）它是一个native方法。native方法的效率一般来说都远高于非native方法。

                    （2）它是一个protected方法。

                    （3）它返回一个Object。

如果我们要在其它类中调用clone方法，那么我们就要重写这个方法，将它的方法属性改为public 。这个方法其实就提供了浅克隆的功能。

验证的代码如下：

Swallow.java:

package com.myclone.test;


public class Swallow implements Cloneable{


	private String name;
	private Wing leftWing;
	private Wing rightWing;
	
	public Swallow(String name, Wing leftWing, Wing rightWing){
		this.name = name;
		this.leftWing = leftWing;
		this.rightWing = rightWing;
	}

	public String getName() {
		return name;
	}

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

	public Wing getLeftWing() {
		return leftWing;
	}

	public void setLeftWing(Wing leftWing) {
		this.leftWing = leftWing;
	}

	public Wing getRightWing() {
		return rightWing;
	}

	public void setRightWing(Wing rightWing) {
		this.rightWing = rightWing;
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO 自动生成的方法存根
		return super.clone();
	}
}

Wing.java: 

package com.myclone.test;

public class Wing{

	private int width;

	public Wing(int width){
		this.width = width;
	}
	
	public int getWidth() {
		return width;
	}

	public void setWidth(int width) {
		this.width = width;
	}
}

Main.java: 

package com.myclone.test;

public class Main {

    public static void main(String[] args) throws CloneNotSupportedException {
        // TODO 自动生成的方法存根

        Swallow s1 = new Swallow("大雁a", new Wing(10), new Wing(10));
        Swallow s2 = (Swallow) s1.clone();
        
        System.out.println("(s1==s2)="+ (s1==s2));
        System.out.println("s1.name="+ s1.getName()+", s2.name="+s2.getName());
        System.out.println("(s1.leftWing==s2.leftWing) = "+(s1.getLeftWing()==s2.getLeftWing()));
        System.out.println("(s1.rightWing==s2.rightWing) = "+(s1.getRightWing()==s2.getRightWing()));    
    }
}

运行结果：

(s1==s2)=false
s1.name=大雁a, s2.name=大雁a
(s1.leftWing==s2.leftWing) = true
(s1.rightWing==s2.rightWing) = true

从运行结果中我们可以看出，调用 s1.clone() 方法我们得到的是另一个对象，它浅克隆了s1，因为s1和s2中的对象属性 leftWing 指向的是同一个实例，rightWing指向的是同一个实例。注意：要调用clone方法，必须要实现 Cloneable接口，在我们这个例子中即Swallow实现了Cloneable接口。


如果我们需要深克隆的对象呢？首先我们想到的是，可以再次重写Swallow中的clone方法，将leftWing 和 rightWing 克隆一份。那么Wing 也要重写它的clone方法，改写后的Wing类：

package com.myclone.test;

public class Wing implements Cloneable{

	private int width;

	public Wing(int width){
		this.width = width;
	}
	
	public int getWidth() {
		return width;
	}

	public void setWidth(int width) {
		this.width = width;
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO 自动生成的方法存根
		return super.clone();
	}
}

改写后的Swallow类： 

package com.myclone.test;


public class Swallow implements Cloneable{


	private String name;
	private Wing leftWing;
	private Wing rightWing;
	
	public Swallow(String name, Wing leftWing, Wing rightWing){
		this.name = name;
		this.leftWing = leftWing;
		this.rightWing = rightWing;
	}

	public String getName() {
		return name;
	}

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

	public Wing getLeftWing() {
		return leftWing;
	}

	public void setLeftWing(Wing leftWing) {
		this.leftWing = leftWing;
	}

	public Wing getRightWing() {
		return rightWing;
	}

	public void setRightWing(Wing rightWing) {
		this.rightWing = rightWing;
	}
	
//	@Override
//	protected Object clone() throws CloneNotSupportedException {
//		// TODO 自动生成的方法存根
//		return super.clone();
//	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO 自动生成的方法存根
		Swallow swallow = (Swallow) super.clone();
		Wing lefWing = (Wing) swallow.getLeftWing().clone();
		Wing rightWing = (Wing) swallow.getRightWing().clone();
		swallow.setLeftWing(lefWing);
		swallow.setRightWing(rightWing);
		return swallow;
	}
}

再次运行Main，得到的结果是：

(s1==s2)=false
s1.name=大雁a, s2.name=大雁a
(s1.leftWing==s2.leftWing) = false
(s1.rightWing==s2.rightWing) = false

可以看出s2已经是s1的深克隆了。这种方法有个缺点就是，如果Wing还含有对象属性的话，那么我们就必须依次去重写属性类的clone方法！

另一种方法是通过序列化和反序列化来实现深克隆。这种方法实际上就是“先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流中，再从流中读出来，便可以重建对象。” ——java.lang.Object.clone()分析

要注意的是所有相关的类都要实现Serializable接口，改写后的实例：

Wing.java

package com.myclone.test;

import java.io.Serializable;

public class Wing implements Cloneable, Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = -6757262538695878009L;
	private int width;

	public Wing(int width){
		this.width = width;
	}
	
	public int getWidth() {
		return width;
	}

	public void setWidth(int width) {
		this.width = width;
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO 自动生成的方法存根
		return super.clone();
	}
}

Swallow.java 

package com.myclone.test;

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


public class Swallow implements Cloneable, Serializable{


	/**
	 * 
	 */
	private static final long serialVersionUID = -2152309743441152834L;
	private String name;
	private Wing leftWing;
	private Wing rightWing;
	
	public Swallow(String name, Wing leftWing, Wing rightWing){
		this.name = name;
		this.leftWing = leftWing;
		this.rightWing = rightWing;
	}

	public String getName() {
		return name;
	}

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

	public Wing getLeftWing() {
		return leftWing;
	}

	public void setLeftWing(Wing leftWing) {
		this.leftWing = leftWing;
	}

	public Wing getRightWing() {
		return rightWing;
	}

	public void setRightWing(Wing rightWing) {
		this.rightWing = rightWing;
	}
	
//	@Override
//	protected Object clone() throws CloneNotSupportedException {
//		// TODO 自动生成的方法存根
//		return super.clone();
//	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO 自动生成的方法存根
		Swallow swallow = (Swallow) super.clone();
		Wing lefWing = (Wing) swallow.getLeftWing().clone();
		Wing rightWing = (Wing) swallow.getRightWing().clone();
		swallow.setLeftWing(lefWing);
		swallow.setRightWing(rightWing);
		return swallow;
	}
	
	/**
	 * 深克隆
	 * @return
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	public Object deepClone() throws IOException, ClassNotFoundException{
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(baos);
		oos.writeObject(this);
		
		ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(bais);
		return ois.readObject();
	}
}

Main.java: 

package com.myclone.test;

import java.io.IOException;

public class Main {

	public static void main(String[] args) throws CloneNotSupportedException, ClassNotFoundException, IOException {
		// TODO 自动生成的方法存根

		Swallow s1 = new Swallow("大雁a", new Wing(10), new Wing(10));
		//Swallow s2 = (Swallow) s1.clone();
		Swallow s2 = (Swallow) s1.deepClone();
		
		System.out.println("(s1==s2)="+ (s1==s2));
		System.out.println("s1.name="+ s1.getName()+", s2.name="+s2.getName());
		System.out.println("(s1.leftWing==s2.leftWing) = "+(s1.getLeftWing()==s2.getLeftWing()));
		System.out.println("(s1.rightWing==s2.rightWing) = "+(s1.getRightWing()==s2.getRightWing()));	 
	}
}

运行结果：

(s1==s2)=false
s1.name=大雁a, s2.name=大雁a
(s1.leftWing==s2.leftWing) = false
(s1.rightWing==s2.rightWing) = false


由此可见，通过序列化和反序列化来实现深克隆是最优雅、最方便的。

2015.09.02  补充:

上午有个同事说深克隆还有一个方法，就是用json，这的确是一个好方法！那么，我们可以在Swallow 类中再加一个deepClone2方法，效果是一样的：

public Swallow deepClone2(){
        Gson gson = new Gson();
        String json = gson.toJson(this);
        return gson.fromJson(json, this.getClass());
    }
似乎更简单一些~ 不过当时我就在想这样效率是否会低一些，测试了下10万次克隆，结果如下：

deepClone 方法耗时=1564
deepClone2 方法耗时=4029



逐兔郎
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java提高篇——对象克隆（复制）
weixin_33743880的博客
07-27 4168
假如说你想复制一个简单变量。很简单： int apples = 5; int pears = apples; 不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。 但是如果你复制的是一个对象，情况就有些复杂了。 假设说我是一个beginner，我会这样写： class St...
浅克隆与深克隆的区别及特点
weixin_43520586的博客
06-29 7462
浅克隆与深克隆的区别 1、浅克隆:对当前对象进行克隆,并克隆该对象所包含的8种基本数据类型和String类型属性（拷贝一份该对象并重新分配内存，即产生了新的对象）；但如果被克隆的对象中包含除8中数据类型和String类型外的其他类型的属性,浅克隆并不会克隆这些属性（即不会为这些属性分配内存，而是引用原来对象中的属性）。 2、深克隆:深克隆是在浅克隆的基础上，递归地克隆除8种基本数据类型和String类型外的属性（即为这些属性重新分配内存而非引用原来对象中的属性） 浅克隆与深克隆的特点 1、被克隆的对象的类
java中的深克隆与浅克隆
qq_61267719的博客
06-12 860
用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。
【Java编程进阶之路 05】深入探索：Java中的浅克隆与深克隆的原理与实现
最新发布
weixin_40736233的博客
02-28 1122
在Java中，克隆是创建对象副本的过程。浅克隆复制对象本身及其非静态字段，但对于引用类型的字段仅复制引用而不复制对象。深克隆则递归地复制对象及其所有引用的对象，确保副本完全独立于原始对象。实现深克隆可通过序列化或自定义方法完成，需处理循环引用和特殊字段。理解并正确选择克隆类型对于确保对象行为至关重要。
java实现简单的克隆（调用Object的clone方法和浅拷贝，深拷贝)
m0_68402491的博客
05-15 1294
的clone方法是protected修饰需要在克隆类中重写2：编译时异常/受查异常3：向下转型时需要强制类型转换4：克隆类需要设置标记接口。
java中浅克隆与深克隆解析
1+1=王的博客
12-10 3683
文章目录简介浅克隆深克隆嵌套使用clone()方法序列化方式浅克隆和深克隆的比较 简介 所谓克隆，就是指依照已存在的数据，复制出一份一样的数据。 java中的克隆有浅克隆和深克隆之分，造成这种区别是因为java中对于基本数据类型和引用类型类型的存储是不一样的，基本数据类型存储在栈中，而引用数据类型存储在堆中，因此造成了在克隆时的不同操作。 实现克隆的方法可以按照三步进行： 实现Clonable接口； 重写clone()方法。 调用clone()方法克隆对象。 浅克隆 package test; imp
Java 深克隆和浅克隆
MustWinner的博客
08-08 528
Java 深克隆和浅克隆 一、为什么要克隆？ 使用场景: 当使用一个对象的属性时，需要进行一些修改，但是又不能直接修改该对象，此时我们就可以使用克隆来拷贝一个对象，进行操作。不然就需要new一个对象，对属性赋值。 总的来说为了保证引用类型的参数不被其他方法修改，可以使用克隆后的值作为参数传递。 一般情况下，我们实际需要使用的是深克隆。二、如何克隆三、代码** 浅克隆 运行结果 深克隆 结果 回顾一下浅克隆和深克隆的概念浅克隆是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象里面包含
实例分析java对象中浅克隆和深克隆
08-26
在本篇文章中我们给大家分享了关于java对象中浅克隆和深克隆的相关知识点和相关代码内容，有兴趣的朋友们学习下。
java 深克隆 浅克隆
11-28
java 深克隆 浅克隆
java 深克隆与浅克隆
09-11
学习java深克隆与浅克隆，希望对你有用
Java浅克隆与深克隆
12-22
浅克隆： package testclone; public class ShallowClone implements Cloneable { public String name; public String[] name2; public ShallowClone() { name2 = new String[2]; } public Object clone() {...
JAVA浅克隆与深克隆
04-07
NULL 博文链接：https://gegeyi.iteye.com/blog/1562016
Java 克隆技术详解，深拷贝与浅拷贝的区别及实现
兴趣是最好的老师，勤能补拙
08-02 1083
克隆是指创建一个对象的副本，使得新创建的对象在内容上与原始对象相同。在编程中，克隆是常用的技术之一，它具有以下几个重要用途和优势：复制对象：使用克隆可以创建一个与原始对象相同的新对象，包括对象的属性和状态。这样可以在不影响原始对象的情况下，对新对象进行修改、操作、传递等。这在某些场景下非常有用，可以避免重新创建和初始化一个对象。隔离性与保护：通过克隆，可以创建一个独立于原始对象的副本。这样，修改克隆对象时，不会影响到原始对象，从而实现了对象之间的隔离性。
JS中深克隆和浅克隆的区别以及如何实现？
weixin_54681929的博客
09-01 1095
目录一、如何实现深克隆与浅克隆？1、浅克隆2、深克隆二、深克隆与浅克隆的区别 最近在回顾之前的笔记时，无意间翻阅到了深克隆和浅克隆的模块，感觉其中涉及了很多以后面试中可能会遇到的问题，所以写下此博客用于加深印象！ 一、如何实现深克隆与浅克隆？ 1、浅克隆 我们可以从其名字中的一个“浅”字展开来说，顾名思义，通过这种方式克隆出来的数据并不能完全脱离原数据，克隆前与克隆后的变量各自的变化却会相互影响，表现的就跟同一个人一样。 原理： 究其原因，这还得追溯回原始值与引用值。引用值是指一些复合类型数据的值，包括Ob
Java中的浅克隆和深克隆详细分析
swadian2008的博客
04-22 903
在Java中，对象的克隆（Clone）可以使用 Object 类的 clone() 方法实现。Java中的克隆分为浅克隆（Shallow Copy）和深克隆（Deep Copy）两种方式。深克隆和浅克隆是为了在需要克隆一个对象时，提供不同的选择。浅克隆会复制对象的所有属性，但是不会复制属性指向的对象，两个对象的属性指向同一个对象。换句话说，浅克隆只是创建了一个新的对象，新对象中的引用类型属性指向的还是原对象中相应的引用类型属性的地址。
浅克隆和深克隆的区别与实现
JinXYan的博客
04-21 4971
什么是克隆 克隆就是依据已经有的数据，创造一份新的完全一样的数据拷贝。 实现克隆有多种方式，可以手工的new出一个新的对象，然后将原来的对象信息一个一个的set到新的对象中。还有就是使用clone方法。使用clone方法必须满足： 对象的类实现Cloneable接口； 覆盖Object类的clone()方法 （覆盖clone()方法，访问修饰符设为public，默认是protected）；...
深克隆、浅克隆
m0_54063422的博客
07-03 246
浅克隆：只复制基本类型的数据，引用类型的数据只复制了引用的地址，引用的对象并没有复制，在新的对象中修改引用类型的数据会影响原对象中的引用。深克隆：是在引用类型的类中也实现了clone，是clone的嵌套，复制后的对象与原对象之间完全不会影响。使用序列化也能完成深复制的功能：对象序列化后写入流中，此时也就不存在引用什么的概念了，再从流中读取，生成新的对象，新对象和原对象之间也是完全互不影响的。使用clone实现的深克隆其实是浅克隆中嵌套了浅克隆，与toString方法类似。
知识点七：Java中深克隆和浅克隆的区别以及实现方式
latata的博客
04-19 622
使用克隆可以为我们快速地构建出一个已有对象的副本，它属于 Java 基础的一部分，也是重要的知识点之一。 那么什么是浅克隆和深克隆？如何实现克隆？ 浅克隆（Shadow Clone）是把原型对象中成员变量为值类型的属性都复制给克隆对象，把原型对象中成员变量为引用类型的引用地址也复制给克隆对象，也就是原型对象中如果有成员变量为引用对象，则此引用对象的地址是共享给原型对象和克隆对象的。 简单来说就是浅...
java实现克隆(浅克隆+深克隆+序列化)
希可诺的博客
04-18 2519
前言：本篇文章从浅克隆，深克隆，序列化逐步进行讲解克隆的实现，语言还是很简单明了的，很适合小白，希望小伙伴们得到收获。 预备工作： 创建两个对象Attachment以及WeeklyLog(也可以自行设置其他对象，这里只是好比对) get,set,构造函数就省略掉咯，小伙伴们自己要记得加上哈。 1、先说最简单的浅克隆 首先：要实现Cloneable接口并复写方法，注意这个浅克隆的类(也就是WeeklyLog) 其次：它默认会调用实现Cloneable接口的方法，然后返回一个对象，而这..
java深克隆和浅克隆
05-10
在 Java 中，对象的克隆分为深克隆和浅克隆两种方式。 浅克隆是指将对象复制一份，但仅复制对象本身和其中的基本类型数据，而不复制对象中的引用类型数据。这意味着，如果原对象中有引用类型的数据，那么复制出来的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值