避免创建不必要的对象

在Java开发中，程序员要尽可能的避免创建相同的功能的对象，因为这样既消耗内存，又影响程序运行速度。在这种情况下可以考虑重复利用对象。

尽量少的创建对象，如果单个对象能够满足要求，就使用单例模式，反复重用唯一的对象。对一些创建成本低的对象来说，这样做带来的好处也许并不明显。但对于一些创建成本高的对象来说，这样做可以明显地节约系统资源、提升系统性能。有以下几种方法：

• 1、采用更合适的API或工具类减少对象的创建
• 2、重用相同功能的对象
• 3、小心自动装箱（auto boxing）
• 4、用静态工厂方法而不是构造器

1、采用更合适的API或工具类减少对象的创建

可能导致滥用对象的一个典型例子就是 字符串 。在学习Java基础的过程中，一定会提到String类的对象一旦被创建，它的值就是不能改变的。通过查看JDK中String类的源码，我们可以看到String类是通过一个 byte数组 来存储字符串的，而且这个数组被修饰为final常量。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence,
               Constable, ConstantDesc ​
    /**     
    * The value is used for character storage.    
    *  ...    
    */
    @Stable
    private final byte[] value;
        
    ...

 /*     
    * JDK9之前，String类是用一个char数组来存储字符串的。如果你觉得上面用byte数组来存储字符串不好理解           
    * 的话，也可以简单地理解为String类仍是用一个char数组来存储字符串     
    */
    private final char value[];

如下两种写法看似没有什么区别，但是如果深入jvm底层了解，我们可以利用jvm运行时常量池的特性，避免创建具有相同功能的String对象（尤其是在循环内部创建）可以带来比较可观的性能优化以及节约内存。

// 每次都会创建一个新的String对象，且不会加入常量池
String str = new String("aaa");

因为当我们往构造方法里传入aaa的时候，其实这个aaa就是一个String实例了。我们等于是创建了两个String实例，参数”aaa”本身就是一个String对象，new String()又会产生新的String对象。

正确的做法如下：

String str = "aaa";

根据jdk文档，上述方式实际上等同于：

char data[] = 'a', 'a', 'a';
String str = new String(data);

传入一个字符数组来创建String，避免了创建重复对象。

再举一个常见的例子，我们有时希望遍历一个list，将其中的元素存到一个字符串里，并用逗号分隔。我们可能会用下面这种最low的办法：

public static String listToString(List<String> list) 
    String str = "";
    for (int i = 0; i < list.size(); i++) 
        str += list.get(i);
        if (i < list.size() - 1) 
            str += ",";
        
    
    return str;

这样其实在每次+=的时候都会重新创建String对象，极大地影响了性能。
我们可以修改一下，采用StringBuilder的方式来拼接list：

public static String listToString(List<String> list) 
    StringBuilder stringBuilder = new StringBuilder();
    for (int i = 0; i < list.size(); i++) 
        stringBuilder.append(list.get(i));
        if (i < list.size() - 1) 
            stringBuilder.append(",");
        
    
    return stringBuilder.toString();

除此之外，刚写Java代码的程序员们，也要正确的选择String、StringBuilder、StringBuffer类的使用。

• String为不可变对象，通常用于定义不变字符串；
• StringBuilder、StringBuffer用于可变字符串操作场景，如字符串拼接；
  • 其中StringBuffer是线程安全的，它通过Synchronized关键字来实现线程同步。

// StringBuffer中的append()方法
public synchronized StringBuffer append(String str) 
    toStringCache = null;
    super.append(str);
    return this;

 
// StringBuilder中的append()方法
public StringBuilder append(String str) 
    super.append(str);
    return this;

2、重用相同功能的对象

一、重用那些已知不会被修改的可变对象。

修改前

public class Demo1 

    private final Date birthday;

    public Demo1(Date birthday) 
        this.birthday = birthday;
    
    
    //不可取，每一次调动都会新建一个Calendar，一个TimeZone和两个Date
    public Boolean isBabyBoomer()
        //Unnecessary allocation of expensive omitted  被忽略的昂贵的不必要分配
        Calendar gmt = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        System.out.println(gmt);
        gmt.set(1946,Calendar.JANUARY,1,0,0,0);
        Date startTime = gmt.getTime();
        gmt.set(1965,Calendar.JANUARY,1,0,0,0);
        Date endTime = gmt.getTime();
        return birthday.compareTo(startTime)>= 0 &&birthday.compareTo(endTime)<0 ;
    

    public static void main(String[] args) 
        Demo1 demo1 = new Demo1(new Date());
        Boolean babyBoomer = demo1.isBabyBoomer();
        Demo1 demo12= new Demo1(new Date());
        Boolean babyBoomer1 = demo12.isBabyBoomer();
    

不可取，每一次调动都会新建一个Calendar，一个TimeZone和两个Date

修改后：

public class Demo2 
    private final Date birthday;

    public Demo2(Date birthday) 
        this.birthday = birthday;
    

    private static final Date startTime;
    private static final Date endTime;

    //静态代码块
    static 
        Calendar gmt = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        System.out.println(gmt);
        gmt.set(1946,Calendar.JANUARY,1,0,0,0);
        startTime = gmt.getTime();
        gmt.set(1965,Calendar.JANUARY,1,0,0,0);
        endTime = gmt.getTime();
    

    public boolean isBabyBoomer()
        return birthday.compareTo(startTime)>= 0 &&birthday.compareTo(endTime)<0 ;
    

    public static void main(String[] args) 
        Demo2 d1 = new Demo2(new Date());
        boolean b1 = d1.isBabyBoomer();
        Demo2 d2 = new Demo2(new Date());
        boolean b2 = d2.isBabyBoomer();
    

改进后Demo2 类只会在初始化的时候创建Calendar，TimeZone和Date实例一次，而不是每一次调用isBabyBoomer()方法都创建一次。既提高了性能又使代码的含义更加清晰了。

二、上面我们谈到了一个不可变对象的重用，接下来我们再看看可变对象的重用。

可变对象的重用可以通过视图（views）来实现。比如，Map的keySet()方法就会返回Map对象所有key的Set视图。这个视图是可变的，但是当Map对象不变时，在任何地方返回的任何一个keySet都是一样的，当Map对象改变时，所有的keySet也会相应的发生改变。

package com.czgo.effective;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestKeySet 

    public static void main(String[] args) 

        Map<String,Object> map = new HashMap<String,Object>();
        map.put("A", "A");
        map.put("B", "B");
        map.put("C", "C");

        Set<String> set = map.keySet();
        Iterator<String> it = set.iterator();
        while(it.hasNext())
            System.out.println(it.next()+"①");
        

        System.out.println("---------------");

        map.put("D", "D");
        set = map.keySet();
        it = set.iterator();
        while(it.hasNext())
            System.out.println(it.next()+"②");
        

    

3 、小心自动装箱（auto boxing）

public class Main 
    public static void main(String[] args) 
        final long startTime = System.currentTimeMillis();​
        Long sum = 0L; // 将sum声明为Long类型        
        for (long i = 0; i <= Integer.MAX_VALUE; i++) 
            sum += i;
        ​
        final long endTime = System.currentTimeMillis();​
        System.out.println("程序执行了：" + (endTime - startTime) + "ms");
    

程序执行了：7298ms

将sum声明为Long类型时，程序大约会构造 个多余的 Long实例。

如果将sum声明为long类型，程序的执行时间会大大地缩短。

public class Main 
    public static void main(String[] args) 
        final long startTime = System.currentTimeMillis();​
        long sum = 0L; // 将sum声明为long类型        for (long i = 0; i <= Integer.MAX_VALUE; i++) 
            sum += i;
        ​
        final long endTime = System.currentTimeMillis();​
        System.out.println("程序执行了：" + (endTime - startTime) + "ms");
    

程序执行了：1308ms

由此，我们可以得出结论：

• 优先使用基本数据类型
• 避免不必要的自动装箱

所以我们在日常开发中，方法内尽量用基本类型，只在入出参的地方用包装类型。多留心，切忌无意识地使用到自动装箱。

4 、用静态工厂方法而不是构造器

对于同时提供了静态工厂方法和构造器的不可变类，通常可以使用静态工厂方法而不是构造器，以避免创建不必要的对象。

Boolean是常用的类型，在开发中也应该使用Boolean.valueof()而不是new Boolean()，从Boolean的源码可以看出，Boolean类定义了两个final static的属性，而Boolean.valueof()直接返回的是定义的这两个属性，而new Boolean()却会创建新的对象。

public static final Boolean TRUE = new Boolean(true);
 
public static final Boolean FALSE = new Boolean(false);

静态工厂方法Boolean.valueOf(String)几乎总是优先于构造器Boolean(String)。构造器在每次被调用的时候都会创建一个新的对象，而静态工厂方法则从来不要求这样做，实际上也不会这样做。

package com.czgo.effective;

/**
 * 用valueOf()静态工厂方法代替构造器
 *
 */
public class Test 

    public static void main(String[] args) 
        // 使用带参构造器
        Integer a1 = new Integer("1");
        Integer a2 = new Integer("1");

        //使用valueOf()静态工厂方法
        Integer a3 = Integer.valueOf("1");
        Integer a4 = Integer.valueOf("1");

        //结果为false，因为创建了不同的对象
        System.out.println(a1 == a2);

        //结果为true，因为不会新建对象
        System.out.println(a3 == a4);
    

5 、正则表达式

正则表达式我们经常用于字符串是否合法的校验，Java中正则表达式

public static void main(String[] args) 
 
    String email = "1057301174@qq.com";
    String regex = "^([a-z0-9A-Z]+[-|\\\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\\\.)+[a-zA-Z]2,$";
 
    long start = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) 
        email.matches(regex);
    
 
    System.out.println(System.currentTimeMillis() - start);
 

执行这段代码的时间，一共耗时71毫秒，看似好像挺快的！

但是我们做个非常简单的优化，优化后的代码如下所示：

public static void main(String[] args) 
 
    String email = "1057301174@qq.com";
    String regex = "^([a-z0-9A-Z]+[-|\\\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\\\.)+[a-zA-Z]2,$";
    Pattern pattern = Pattern.compile(regex);
 
    long start = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) 
        //email.matches(regex);
        pattern.matcher(email);
    
 
    System.out.println(System.currentTimeMillis() - start);
 

再次执行代码，一共耗时1毫秒

这是因为String.matches()方法在循环中创建时，每次都需要执行Pattern.compile(regex)，而创建Patter实例的成本很高，因为需要将正则表达式编译成一个有限状态机（ finite state machine）。

6、补

如果涉及到对象池的应用，除非池中的对象非常重，类似数据库连接，否则最好不要去自己维护一个对象池，因为这样会很复杂。另外，有时考虑到系统的安全性，那么我们需要进行防御性复制，这个在后面会讲到。此时，重复创建对象就是有意义的，因为比起隐含错误和安全漏洞，重复创建对象带来的性能损失是可以接受的。

参考

1、如何在Java中避免创建不必要的对象（备战2022春招或暑期实习，每天进步一点点，打卡100天，Day1）
2、《Effective Java》阅读笔记5 避免创建不必要的对象