尽量不用+直接拼接字符串，使用StringBuilder来进行拼接

看测试代码

package com.csea;

/**
 * @author Csea
 * @title
 * @date 2020/4/26 16:33
 */
public class StringAppend {
    public static void main(String[] args) {
        long times = System.currentTimeMillis();
        stringAddJoin();
        System.out.println("使用 + 拼接字符串耗时:" + (System.currentTimeMillis() - times));

        times = System.currentTimeMillis();
        stringBuilderJoin();
        System.out.println("使用 StringBuilder 拼接字符串耗时:" + (System.currentTimeMillis() - times));
    }

    public static String stringAddJoin() {
        String result = "";
        for (int i = 0; i < 10000; i++) {
            result += (i + "csea");
        }
        return result;
    }

    public static String stringBuilderJoin() {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            result.append(i).append("csea");
        }
        return result.toString();
    }
}

输出

使用 + 拼接字符串耗时:849
使用 StringBuilder 拼接字符串耗时:1

可以看到，这个时间上是差距了几百倍，至于是为什么

以+来拼接字符串：

其实在用+进行字符串的拼接的时候，他的底层实际上每一次循环都在new 一个新的StringBuilder，然后使用append()方法来把字符串拼接上

StringBuilder拼接字符串

每次循环直接采用append()方法来把字符串拼接上

append()方法如下，继承了AbstractStringBuilder
StringBuilder的底层下也是一个字节数组，并且是可以进行修改的，当数组长度不够用的时候会调用ensureCapacityInternal()中的Arrays.copyOf()进行扩容，最后拼接成字符串

	@Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

appendNull()如下

    private AbstractStringBuilder appendNull() {
        int c = count;
        ensureCapacityInternal(c + 4);
        final char[] value = this.value;
        value[c++] = 'n';
        value[c++] = 'u';
        value[c++] = 'l';
        value[c++] = 'l';
        count = c;
        return this;
    }

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }