JAVA高级技术-对象克隆（几种深克隆效率比较）

已于 2023-07-10 21:37:07 修改
阅读量1.1w 收藏 28
点赞数 30
分类专栏： JAVA相关的 文章标签： java 开发语言
于 2023-07-01 11:15:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shi_hong_fei_hei/article/details/131488447
版权

回城传送–》《JAVA筑基100例》

文章目录

一、题目描述

题目：对象的克隆是Java一项高级技术，可以根据给定的对象，获得与其完全相同的另一个对象。

前面介绍了三种实现深克隆的方式，现在对这三种方式克隆10万个对象，并输出花费的时间。这样大家就可以有个直观的认识。

二、解题思路-序列化克隆

再创建一个员工类Employee

定义三个成员变量表示：员工名字，年龄

使用构造方法对它们进行赋值。

并提供对应的get方法和set方法。

重写toString()方法和clone()方法。

三、代码详解

员工类：

public class Employee implements Cloneable, Serializable {
    private static final long serialVersionUID = 5022956767440380940L;
    private String name; // 表示员工的姓名
    private int age; // 表示员工的年龄

    public Employee(String name, int age) {// 利用构造方法初始化各个域
        this.name = name;
        this.age = age;
    }

    public Employee() {// 利用构造方法初始化各个域
        super();
    }

    @Override
    public String toString() {// 重写toString()方法
        StringBuilder sb = new StringBuilder();
        sb.append("姓名：" + name + ", ");
        sb.append("年龄：" + age + "\n");
        return sb.toString();
    }

    @Override
    protected Employee clone() {// 使用父类的clone()方法实现深克隆
        Employee employee = null;
        try {
            employee = (Employee) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return employee;
    }
}

测试类

public class Test {

    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<Employee>();// 创建列表保存对象
        Employee employee = new Employee("小虚竹", 25);// 创建Employee类的对象
        long currentTime = System.currentTimeMillis();// 获得当前系统时间
        for (int i = 0; i < 100000; i++) {
            employees.add(employee.clone());// 使用克隆方式获得对象
        }
        System.out.println("clone()方法克隆花费时间：" + (System.currentTimeMillis() - currentTime) + "毫秒");
        currentTime = System.currentTimeMillis();// 获得当前时间

        for (int i = 0; i < 100000; i++) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();// 创建字节数组输出流
            ObjectOutputStream out = null;
            try {
                out = new ObjectOutputStream(baos);// 创建对象输出流
                out.writeObject(employee);// 将对象写入到输出流中
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (out != null) {
                    try {
                        out.close();// 释放资源
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            // 获得字节数组输出流内容
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream in = null;
            try {
                in = new ObjectInputStream(bais);// 创建对象输入流
                employees.add((Employee) in.readObject());// 读取对象
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close();// 释放资源
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        System.out.println("序列化花费时间：" + (System.currentTimeMillis() - currentTime) + "毫秒");
        currentTime = System.currentTimeMillis();// 获得当前时间
        
        for (int i = 0; i < 100000; i++) {
            Employee employee2 = new Employee();
            BeanUtils.copyProperties(employee,employee2);
        }
        System.out.println("BeanUtils.copyProperties花费时间：" + (System.currentTimeMillis() - currentTime) + "毫秒");
    }
}

如图

原生序列化和Kryo序列化性能比较

原生序列化：

package com.xiaoxuzhu;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * Description: 原生序列化
 *
 * @author xiaoxuzhu
 * @version 1.0
 *
 * <pre>
 * 修改记录:
 * 修改后版本	        修改人		修改日期			修改内容
 * 2022/5/20.1	    xiaoxuzhu		2022/5/20		    Create
 * </pre>
 * @date 2022/5/20
 */
public class OriginalSerializable {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        long start =  System.currentTimeMillis();
        setSerializableObject();
        System.out.println("java原生序列化时间:" + (System.currentTimeMillis() - start) + " ms" );
        start =  System.currentTimeMillis();
        getSerializableObject();
        System.out.println("java原生反序列化时间:" + (System.currentTimeMillis() - start) + " ms");
    }

    public static void setSerializableObject() throws IOException{

        FileOutputStream fo = new FileOutputStream("D:/file.bin");
        ObjectOutputStream so = new ObjectOutputStream(fo);
        Employee employee = null;
        for (int i = 0; i < 100000; i++) {
             employee = new Employee("小虚竹", 25);// 创建Employee类的对象
            so.writeObject(employee);
        }
        so.writeObject(null);//为了解决EOF异常
        so.flush();
        so.close();
    }

    public static void getSerializableObject(){
        FileInputStream fi;
        try {
            fi = new FileInputStream("D:/file.bin");
            ObjectInputStream si = new ObjectInputStream(fi);

            Employee employee =null;
            while((employee=(Employee)si.readObject()) != null){
            }
            fi.close();
            si.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();  
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

Kyro序列化:

package com.xiaoxuzhu;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import org.objenesis.strategy.StdInstantiatorStrategy;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.KryoException;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
/**
 * Description: Kyro序列化
 *    kryo.KryoException: Buffer underflow.
 * @author xiaoxuzhu
 * @version 1.0
 *
 * <pre>
 * 修改记录:
 * 修改后版本	        修改人		修改日期			修改内容
 * 2022/5/20.1	    xiaoxuzhu		2022/5/20		    Create
 * </pre>
 * @date 2022/5/20
 */
public class KyroSerializable {
    public static void main(String[] args) throws IOException {
        long start =  System.currentTimeMillis();
        setSerializableObject();
        System.out.println("Kryo 序列化时间:" + (System.currentTimeMillis() - start) + " ms" );
        start =  System.currentTimeMillis();
        getSerializableObject();
        System.out.println("Kryo 反序列化时间:" + (System.currentTimeMillis() - start) + " ms");

    }

    public static void setSerializableObject() {
        Output output = null;
        try {
            Kryo kryo = new Kryo();
            kryo.setReferences(false);
            kryo.setRegistrationRequired(false);
            kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
            kryo.register(Employee.class);
             output = new Output(new FileOutputStream("D:/file1.bin"));
            Employee employee = null;
            for (int i = 0; i < 100000; i++) {
                employee = new Employee("小虚竹", 25);// 创建Employee类的对象
                kryo.writeObject(output, employee);
            }
            output.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(output !=null){
                output.close();
            }
        }
    }


    public static void getSerializableObject(){
        Kryo kryo = new Kryo();
        kryo.setReferences(false);
        kryo.setRegistrationRequired(false);
        kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
        Input input = null;
        try {
            input = new Input(new FileInputStream("D:/file1.bin"));
            Employee employee =null;
            while((employee=kryo.readObject(input, Employee.class)) != null){
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch(KryoException e){
        }finally {
            if(input !=null){
                input.close();
            }
        }
    }

}

10万条测试结果：

java原生序列化时间:2762 ms
java原生反序列化时间:3405 ms

Kryo 序列化时间:575 ms
Kryo 反序列化时间:156 ms

Kryo 的性能是原生的序列化性能二十几倍。

结论

1、使用clone方法克隆（不实用）：

- 优点：最快的，10万条数据可以控制在100ms内
- 缺点：但这个的使用也是最麻烦的，类要重写clone方法，有引类类型的参数类也要重写clone方法

2、使用原生序列化克隆（不实用）：

- 优点：序列化不需要每个对象都重写clone方法，同时支持类里的引用类型参数的深克隆
- 缺点：花费的时间最长

3、使用第三方工具方法 BeanUtils.copyProperties，克隆时间适中：

- 优点：使用简单方便
- 缺点：只能进行浅克隆，对于引用类型的参数是无法克隆的，只是复制引用，不是克隆值 ，所以要额外处理。

4、使用Kryo 序列化效果比用原生序列化好

企业级应用开发中：

  • 简单的对象克隆（浅克隆），可以用 BeanUtils.copyProperties

  • 复杂对象的序列化克隆，可以用Kryo 序列化处理。

四、推荐专栏

《JAVA从零到壹》

《JAVA从零到壹》第四讲：类与对象基础

第六讲：数组包及访问控制

《JAVA从零到壹》第七讲：面向对象高级特性

小虚竹
关注
  • 30
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 17
    评论
专栏目录
实现数组复制常用的5种方式及组合类的深复制(深拷贝)
12-21
接下来，我们看下这几种方法的效率和源码，以及如何使用序列化和反序列化实现组合类的深复制。 我们以百万级和千万级的数据作为测试集。测试源码如下： public static void main(String[] args) throws ...
Java常见面试题208道.docx
05-17
15.java 中 IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和 Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21....
Java对象-深拷贝(实现Serializable, Cloneable两种方式)
weixin_44602460的博客
06-21 1131
一. 使用序列化流实现 方法 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。 实体类 School package entity; import java.io.*; import java.util.List; public class School implements Serializable { private List<Student> students; private String sclNo; p
Java对象深拷贝的几种方式
penn
05-16 8184
java对象拷贝的几种方式
java中的深克隆与浅克隆
qq_61267719的博客
06-12 873
用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。
一文搞懂 Java 克隆技术，深拷贝与浅拷贝的区别及实现
m0_71777195的博客
08-03 243
深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是在克隆（Clone）操作中经常遇到的两个概念，它们描述了克隆操作对于对象内部引用的处理方式。浅拷贝（Shallow Copy）：浅拷贝指在克隆操作中，只复制对象本身以及对象内部的基本数据类型的属性，而不复制对象内部的引用类型的属性。浅拷贝仅仅创建了一个新对象，该对象与原始对象共享对同一引用类型属性的访问。如果原始对象的引用类型属性被修改，浅拷贝的对象也会受到影响。
java clone() 方法详解及深克隆与浅克隆
weixin_42361467的博客
05-12 1495
clone 翻译过来就是克隆，顾名思义就是创造一个一模一样的事物。Java 代码中 clone() 方法是 Object 方法，而 Object 又是所有类的父类，也就是说所有 java 对象都可以调用 clone 方法克隆一个和自己“相同”的对象。本篇博客我打算系统整理 java clone() 方法的原理以及深克隆和浅克隆的关系。
Java深克隆的几种方式
weixin_37672801的博客
02-21 5025
Serializable接口、Cloneable接口、序列化、字节流。
深克隆、浅克隆
m0_54063422的博客
07-03 263
浅克隆：只复制基本类型的数据，引用类型的数据只复制了引用的地址，引用的对象并没有复制，在新的对象中修改引用类型的数据会影响原对象中的引用。深克隆：是在引用类型的类中也实现了clone，是clone的嵌套，复制后的对象与原对象之间完全不会影响。使用序列化也能完成深复制的功能：对象序列化后写入流中，此时也就不存在引用什么的概念了，再从流中读取，生成新的对象，新对象和原对象之间也是完全互不影响的。使用clone实现的深克隆其实是浅克隆中嵌套了浅克隆，与toString方法类似。
java中浅克隆与深克隆解析
1+1=王的博客
12-10 3701
文章目录简介浅克隆深克隆嵌套使用clone()方法序列化方式浅克隆和深克隆的比较 简介 所谓克隆，就是指依照已存在的数据，复制出一份一样的数据。 java中的克隆有浅克隆和深克隆之分，造成这种区别是因为java中对于基本数据类型和引用类型类型的存储是不一样的，基本数据类型存储在栈中，而引用数据类型存储在堆中，因此造成了在克隆时的不同操作。 实现克隆的方法可以按照三步进行： 实现Clonable接口； 重写clone()方法。 调用clone()方法克隆对象。 浅克隆 package test; imp
js中，深克隆、浅克隆的概念，以及手写一个深克隆函数
qq_68155756的博客
05-10 312
在 JavaScript 中，浅克隆可以使用 Object.assign() 或展开符（…）来实现。深克隆通常使用递归函数 或 第三方库（如 Lodash 或 jQuery）来实现，某些情况下使用JSON.parse(JSON.stringify(obj))也能实现，之所以说某些情况下是因为使用此方式的时候，如果对象包含函数、日期、正则表达式等属性 会将这些属性转换为 null。
c c++ 函数内数组初值_C 从函数返回指针
weixin_39878646的博客
11-29 161
C 指针在上一章中，我们已经了解了 C 语言中如何从函数返回数组，类似地，C 允许您从函数返回指针。为了做到这点，您必须声明一个返回指针的函数，如下所示：int * myFunction(){...}另外，C 语言不支持在调用函数时返回局部变量的地址，除非定义局部变量为static变量。现在，让我们来看下面的函数，它会生成 10 个随机数，并使用表示指针的数组名(即第一个数组元素的...
Java经典编程源码基础例程300.zip
04-25
实例058 深克隆效率的比较 87 第7章 面向对象进阶 89 实例059 经理与员工的差异 90 实例060 重写父类中的方法 92 实例061 计算几何图形的面积 93 实例062 简单的汽车销售商场 95 实例063 使用Comparable接口自定 义...
高级开发jvm面试题和答案.pdf
11-26
对象的浅克隆和深克隆； 类加载 类加载过程（类加载从磁盘上将字节码文件(.class文件)中的内容读入虚拟机，并保存起来） 类加载特性 ； 类加载的时机： 三种类加载器： 双亲委派机制概念； 怎么解决双亲委派机制； ...
史上最全java面试，103项重点知识，带目录
07-28
15. java 中 IO 流分为几种？ 7 16. BIO、NIO、AIO 有什么区别？ 7 17. Files的常用方法都有哪些？ 8 二、容器 8 18. java 容器都有哪些？ 8 19. Collection 和 Collections 有什么区别？ 9 20. List、Set、Map 之间...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 453
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 511
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1535
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 712
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
java new 对象克隆的两种方法
09-03
在Java语言中，我们可以使用两种方法来实现对象的克隆。 1. 通过实现Cloneable接口并重写clone()方法： 首先，在需要克隆的对象类中实现Cloneable接口，该接口是一个标记接口，表示该类支持克隆操作。然后，重写clone()方法，该方法是Object类中的一个非final方法，用于创建并返回一个新的对象。在这个方法内部，我们可以调用super.clone()方法来获得一个浅表克隆，也可以根据需要对属性进行深度克隆。最后，我们可以通过调用该对象的clone()方法来创建该对象的一个克隆副本。 2. 通过实现Serializable接口并使用序列化和反序列化： 首先，在需要克隆的对象类中实现Serializable接口，该接口是一个标记接口，表示该类支持序列化。然后，我们可以通过将该对象序列化为字节流，并再将字节流反序列化为一个新的对象来实现克隆。这种方法实现了对象的深拷贝，即复制了原对象及其内部的所有引用对象。 这两种方法在使用上有一些不同。实现Cloneable接口并重写clone()方法的方式更为直接，但需要开发者自行处理属性深度克隆问题。而使用序列化和反序列化方式则相对更容易实现对象的深拷贝，但在性能上略逊于直接克隆。 需要注意的是，使用clone()方法进行对象克隆时，会调用对象的构造函数来创建新的对象，而使用序列化和反序列化方式则不会。所以在使用这两种方法时，需要确保对象类的构造函数是正确的和可访问的。此外，还需要确保被克隆的对象类中的所有引用类型的成员变量都是可序列化的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小虚竹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值