【第36题】JAVA高级技术-对象克隆5（几种深克隆效率比较）

迈不过友情╰ 2023-10-08 15:19 32阅读 0赞

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

#### 文章目录 ####

*  零、前言
 *  一、题目描述
 *  二、解题思路-序列化克隆
 *  三、代码详解
 *   *  原生序列化和Kryo序列化性能比较
     *  结论
 *  四、推荐专栏
 *  五、示例源码下载

## 零、前言 ##

今天是学习 **JAVA语言** 打卡的第36天，每天我会提供一篇文章供群成员阅读（ **不需要订阅付钱** ），读完文章之后，按解题思路，自己再实现一遍。在[小虚竹JAVA社区][JAVA] 中对应的 【打卡贴】打卡，今天的任务就算完成了。

因为大家都在一起学习同一篇文章，所以有什么问题都可以在群里问，群里的小伙伴可以迅速地帮到你，一个人可以走得很快，一群人可以走得很远，有一起学习交流的战友，是多么幸运的事情。

学完后，自己写篇学习报告的博客，可以发布到[小虚竹JAVA社区][JAVA] ，供学弟学妹们参考。

我的学习策略很简单，题海策略+ 费曼学习法。如果能把这100题都认认真真自己实现一遍，那意味着 **JAVA语言** 已经筑基成功了。后面的进阶学习，可以继续跟着我，一起走向架构师之路。

## 一、题目描述 ##

题目：对象的克隆是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) + "毫秒");
        }
    }

![如图][e28a1ed75cba7a3c915323215b8cc8c1.png]

### 原生序列化和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 1]

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

[第六讲：数组包及访问控制][Link 1]

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

## 五、示例源码下载 ##

关注下面的公众号，回复筑基+题目号

> 筑基36

[JAVA_100]: https://blog.csdn.net/shi_hong_fei_hei/category_11671734.html
[JAVA]: https://bbs.csdn.net/forums/xiaoxuzhu
[e28a1ed75cba7a3c915323215b8cc8c1.png]: https://img-blog.csdnimg.cn/img_convert/e28a1ed75cba7a3c915323215b8cc8c1.png
[JAVA 1]: https://blog.csdn.net/shi_hong_fei_hei/category_11632097.html
[JAVA 2]: https://xiaoxuzhu.blog.csdn.net/article/details/123166782
[Link 1]: https://xiaoxuzhu.blog.csdn.net/article/details/123166875
[JAVA 3]: https://xiaoxuzhu.blog.csdn.net/article/details/123166888