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

た入场券 2024-04-08 12:49 21阅读 0赞

#### 目录 ####

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