Java克隆方式避免频繁创建对象优化方案

Posted 2022-08-30 赵广陆

目录

• 1 克隆介绍
• • 1.1 浅克隆
  • • 1.1.1 浅克隆实现：
    • 1.1.2 浅拷贝
  • 1.2 深克隆
  • • 1.2.1 递归调用clone()方法
    • 1.2.2 通过序列化方式
• 3 Java频繁创建对象优化方案
• • 3.1 优化思路
  • 3.2 具体实现

---

1 克隆介绍

直接使用new关键字创建的对象，是一个新的对象，没有任何数据(初始化的默认值)
使用克隆创建的对象，可以复制对象的数据
Java中数据类型有值类型(八大基本数据类型)和引用类型(类，数组，接口)
基本类型复制值，引用类型复制引用地址而不是对象本身

浅克隆、深克隆区别在于是否支持引用类型的成员变量的复制

1.1 浅克隆

• 如果对象的成员变量是基本类型，克隆对象会拿到成员的值
• 如果对象的成员变量是引用类型，克隆对象会拿到成员的引用地址

在浅克隆中：源对象和克隆对象的成员变量指向相同的内存地址

1.1.1 浅克隆实现：

1.1.2 浅拷贝

1、实现Cloneable接口，重写Object中的clone()方法
谈此之前，我们先看一个例子，定义一个名为 Company 的类，并添加一个类型为 User 的成员变量：

public class Company implements Cloneable

    private User user;

    private String address;

    public Company(User user, String address) 
        super();
        this.user = user;
        this.address = address;
    

    public User getUser() 
        return user;
    

    public void setUser(User user) 
        this.user = user;
    

    public String getAddress() 
        return address;
    

    public void setAddress(String address) 
        this.address = address;
    

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

    @Override
    public boolean equals(Object obj) 
        Company company = (Company) obj;
        if (user.equals(company.getUser()) && address.equals(company.address)) 
            return true;
        
        return false;
    

测试代码及测试结果如下：

    public static void main(String[] args) throws CloneNotSupportedException
        Company companyOne, companyTwo, companyThree;
        companyOne = new Company(new User("username", "password"), "上海市");
        companyTwo = companyOne;
        companyThree = (Company) companyOne.clone();

        System.out.println(companyTwo==companyOne);                //true
        System.out.println(companyTwo.equals(companyOne));        //true

        System.out.println(companyThree==companyOne);            //false
        System.out.println(companyThree.equals(companyOne));    //true

        System.out.println(companyThree.getUser()==companyOne.getUser());            //true ? 这里为什么不是false呢
        System.out.println(companyThree.getUser().equals(companyOne.getUser()));    //true

    

问题来了，companyThree 与 companyOne 中的 User 是同一个对象！也就是说 companyThree 只是克隆了 companyOne 的基本数据类型的数据，而对于引用类型的数据没有进行深度的克隆。也就是俗称的浅克隆。

浅克隆：顾名思义，就是很表层的克隆，只克隆对象自身的引用地址；

深克隆：也称“N层克隆”，克隆对象自身以及对象所包含的引用类型对象的引用地址。

这里需要注意的是，对于基本数据类型（primitive）和使用常量池方式创建的String 类型，都会针对原值克隆，所以不存在引用地址一说。当然不包括他们对应的包装类。

1.2 深克隆

1.2.1 递归调用clone()方法

所以使用深克隆就可以解决上述 Company 对象克隆过后两个 user 对象的引用地址相同的问题。我们修改一下 Company 类的 clone() 函数。

    @Override
    protected Object clone() throws CloneNotSupportedException 
        Company company = (Company) super.clone();
        company.user = (User) company.getUser().clone();
        return company;
    

再运行测试代码，就能得到 companyThree.getUser()==companyOne.getUser() 为 false 的结果了。从实现过程来说，递归克隆存在克隆过程多且复杂的缺点。

1.2.2 通过序列化方式

public class Text implements Serializable

    private static final long serialVersionUID = 8723901148964L;

    private int age;

    private Name name;

    public int getAge() 
        return age;
    

    public void setAge(int age) 
        this.age = age;
    

    public Name getName() 
        return name;
    

    public void setName(Name name) 
        this.name = name;
    

    public Object myClone()
        Text text=null;
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        try 
            ObjectOutputStream oos=new ObjectOutputStream(bos);
            oos.writeObject(this);
            ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois=new ObjectInputStream(bis);
            text=(Text)ois.readObject();
         catch (IOException e) 
            e.printStackTrace();
         catch (ClassNotFoundException e) 
            e.printStackTrace();
        
        return text;
    


class Name implements Serializable 

    private static final long serialVersionUID = 872390113109L;

    private String name;

    public String getName() 
        return name;
    

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

    @Override
    public String toString() 
        return name;
    

结果分析：

采用深克隆能有效隔离源对象与克隆对象的联系。

从实现过程来说，递归克隆存在克隆过程多且复杂的缺点，所以建议采用序列化的方式进行深克隆。

总结：

• 浅克隆中，克隆对象的引用对象和原对象使用的同一个对象
• 深克隆中，克隆对象的引用对象都是重新创建的对象,也就是完全独立的两个对象

3 Java频繁创建对象优化方案

目前在项目中，需要频繁的创建对象，导致程序比较慢。

3.1 优化思路

1. 假如创建的对象，需要在 if 判断条件中使用，则在 if 判断条件中new新对象，这样可以减少对象的创建。
2. 使用浅拷贝方案解决

Cloneable

• 对于将会频繁创建的对象，我们要让这个类实现Cloneable接口，因为这个优化的核心，就是利用clone。
• clone的最大特点就是，不会去调用任何构造方法，所以，在我看来重点应该放在构造方法中。下面我们来实现。

3.2 具体实现

1.对于需要频繁创建的实体类，需要实现Serializable和Cloneable接口

2.在此实体类中写一个getInstance()，其中就是返回clone()

import lombok.Data;

import java.io.Serializable;


@Data
public class User implements Serializable,Cloneable

    private static final long serialVersionUID = 1L;
    private static User  user = new User();


    /**
     * 用户id
     */
    private Long userId;
    /**
     * 用户名称
     */
    private String userName;

    /**
     * 调用对象创建优化
     * @return
     */
    public static User getInstance()
        try 
            return (User) user.clone();
         catch (CloneNotSupportedException e) 
            e.printStackTrace();
        
        return new User();
    

3.在方法中新建对象的时候，直接getInstance()就可以。

这样既避免了单例设计模式的线程安全问题，保证每次创建的对象不一样。

if (1=1) 
                    // 将创建对象放到if中，不进入if则不创建，提高效率
//                    SysMenuManagerGrant grant = new SysMenuManagerGrant();
                    User user = User.getInstance();
                

当一个类存在继承关系时，你创建一个子类的对象时，如果在没有明确指定的情况下，子类是会隐式的去调用父类的无参构造的。假设，我们需要频繁创建的对象，是一个继承关系比较深的类的话，调用构造函数的开销不容小窥。
如果一时间内，频繁创建某对象时，这些平时不显眼的消耗一叠加起来，就变得很客观了。但是，当我们使用clone的话，就可以避免这个问题。