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

---

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的话，就可以避免这个问题。