Java中String +、concat、StringBuilder、StringBuffer 性能对比

## 一、简单介绍

往空字符串中 追加`*`字符， 分别用 使用+、concat、StringBuilder、StringBuffer的方法追加 1万、10万、100万次。
测试环境：4C8G、win10、JDK8、idea2021、单线程

## 二、测试代码

```
public class Main {

public static void testString(int size) {
        System.out.println("test size " + size);
        String empty = "*";

String test = "";
        long addTime = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            test += empty;
        }
        System.out.println("ADD cost time:" + (System.currentTimeMillis() - addTime));

test = "";
        long concat = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            test = test.concat(empty);
        }
        System.out.println("concat cost time:" + (System.currentTimeMillis() - concat));

long builderTime = System.currentTimeMillis();
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < size; i++) {
            builder.append(empty);
        }
        System.out.println("builder cost time:" + (System.currentTimeMillis() - builderTime));

long bufferTime = System.currentTimeMillis();
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < size; i++) {
            buffer.append(empty);
        }
        System.out.println("buffer cost time:" + (System.currentTimeMillis() - bufferTime));
        System.out.println();
    }

public static void main(String[] args) {
        testString(10000);
        testString(10_0000);
        testString(100_0000);
    }
}
```

## 三、测试结果

```
test size 10000
ADD cost time:174
concat cost time:26
builder cost time:0
buffer cost time:1

test size 100000
ADD cost time:5383
concat cost time:1503
builder cost time:4
buffer cost time:3

test size 1000000
ADD cost time:314464
concat cost time:195864
builder cost time:13
buffer cost time:10

```

处理为图表

| 测试次数 | +      | concat | StringBuilder | StringBuffer |
| -------- | ------ | ------ | ------------- | ------------ |
| 1w       | 174    | 26     | 0             | 1            |
| 10w      | 5383   | 1503   | 4             | 3            |
| 100w     | 314464 | 195864 | 13            | 10           |

## 四、结果分析

1. `+`的拼接方式效果最差
   编译器会将 `str = str + "*";` 优化为 `str = new StringBuilder().append(str).append("*").toString();`, 但遗憾的是对循环体没有再特殊优化，所以循环几次就创建了几次 `StringBuilder`对象导致效率极低。

2. concat 的拼接方式需要小心使用 需要额外进行 空检查

```
String target = null;
# 返回 null*
System.out.println(target + "*");
# 返回 null*
System.out.println(new StringBuilder().append(target).append("*"));
# 返回 null*
System.out.println(new StringBuffer().append(target).append("*"));
# 抛出 NullPointerException
System.out.println(target.concat("*"));
```

3. StringBuffer在单线程环境下，synchronized关键字的影响不大。
   StringBuffer的函数都被synchronized标注了，在JDK7之前，由于synchronized是重量级锁所以影响性能，大家推荐单线程用StringBuilder，多线程才用StringBuffer，但实际测试下来，单线程也可以直接用StringBuffer。