由于String对象是不可变对象，因此在需要对字符串进行修改操作时（如字符串连接和替换），String对象总是会生成新的对象，所以其性能相对较差。
String常量的累加操作：对于静态字符串的连接操作，Java在编译时会进行彻底的优化，将多个连接操作的字符串在编译时合成一个单独的长字符串。
String变量的累加操作：底层使用了StringBuilder的功能。
1.常量拼接
String str = "String 2"+" "+"EFG";
System.out.println(str);
javac 生成 class，反编译看看：
String var1 = "String 2 EFG";
System.out.println(var1);
javap -verbose class文件 反解析class文件:
Constant pool: #2 = String #16 // String 2 EFG
Code:
stack=2, locals=2, args_size=1
0: ldc #2 // String String 2 EFG
2: astore_1
3: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
6: aload_1
7: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
10: return
可以看到常量拼接的字符串 编译阶段被拼接好了
相当于fianl static String定义的常量字符串，直接放在常量池
2.变量和常量拼接
String str1 = "String 1";
str1=str1+"aaa";
System.out.println(str1);
javac javap看一下
stack=2, locals=2, args_size=1
0: ldc #2 // String String 1
2: astore_1
3: new #3 // class java/lang/StringBuilder
6: dup
7: invokespecial #4 // Method java/lang/StringBuilder."<init>":()V
10: aload_1
11: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
14: ldc #6 // String aaa
16: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
22: astore_1
23: getstatic #8 // Field java/lang/System.out:Ljava/io/PrintStream;
26: aload_1
27: invokevirtual #9 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
30: return
可以看出+号拼接是底层实现是一次StringBuilder初始化后，append了两次
执行一次字符串“+”,
相当于 str = new StringBuilder().append(str).append("aaa").toString()
（注意new StringBuilder(str)其实就是 new StringBuilder().append(str)。所以这里说的是两次append）
2.1 修改拼接 str1=str1+"aaa" +"bbb";
答案是还是append了两次，"aaa" +"bbb" 在编译阶段生成了常量aaabbb
2.2 修改拼接 str1=str1+"aaa"+new String("bbb");
答案：一次StringBuilder初始化后，append了三次，多个变量拼接以此类推
2.3 修改拼接两次 str1=str1+"aaa"； str1=str1+"bbb";
Code:
stack=2, locals=2, args_size=1
0: ldc #2 // String String 1
2: astore_1
3: new #3 // class java/lang/StringBuilder
6: dup
7: invokespecial #4 // Method java/lang/StringBuilder."<init>":()V
10: aload_1
11: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
14: ldc #6 // String aaa
16: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
22: astore_1
23: new #3 // class java/lang/StringBuilder
26: dup
27: invokespecial #4 // Method java/lang/StringBuilder."<init>":()V
30: aload_1
31: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
34: ldc #8 // String bbb
36: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
39: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
42: astore_1
43: getstatic #9 // Field java/lang/System.out:Ljava/io/PrintStream;
46: aload_1
47: invokevirtual #10 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
50: return
答案：生成了两个StringBuilder。
2.4 对比循环拼接字符串
for 循环中使用”+”号操作符。
String result = "";for (int i = 0; i < 100000; i++) { result += "aaa";}
for 循环中使用 append。
StringBuilder sb = new StringBuilder();for (int i = 0; i < 100000; i++) { sb.append("aaa");}
答案：+for 循环中创建了大量的 StringBuilder 对象，而apend代码至始至终只有一个 StringBuilder 对象
2.5 总结：
+实际上是StringBuilder实现的。
尽量一次拼接完。
循环体里避免使用+，因为会循环创建StringBuilder
StringBuilder
1）判断拼接的字符串是不是 null，如果是，当做字符串“null”来处理
2）拼接后的字符数组长度是否超过当前值，如果超过，进行扩容并复制。
3）非线程安全，线程安全可以选择StringBuffer。 StringBuffer 类的 append 方法比 StringBuilder 多了一个关键字 synchronized
3.变量拼接
String 是final对象，不会被修改，每次使用 + 进行拼接都会创建新的对象，而不是改变原来的对象，也属于线程安全的.
3.1 String 类的 concat 方法
每次调用contact()方法就是一次数组的拷贝，虽然在内存中是处理都是原子性操作，速度非常快，但是，最后的return语句会创建一个新String对象，限制了concat方法的速度
public String concat(String var1) {
int var2 = var1.length();
if (var2 == 0) {
return this;
} else {
int var3 = this.value.length;
char[] var4 = Arrays.copyOf(this.value, var3 + var2);
var1.getChars(var4, var3);
return new String(var4, true);
}
}
concat
1）如果拼接的字符串是 null，concat 时候就会抛出NullPointerException
2）如果拼接的字符串是一个空字符串（""），那么 concat 的效率要更高一点。
3）如果拼接的字符串非常多，concat 的效率就会下降，因为创建的字符串对象越多，开销就越大。
3.2 String 类的 join 方法
JDK 1.8 提供了一种新的字符串拼接姿势：String 类增加了一个静态方法 join。
public static String join(CharSequence var0, CharSequence... var1) {
Objects.requireNonNull(var0);
Objects.requireNonNull(var1);
StringJoiner var2 = new StringJoiner(var0);
CharSequence[] var3 = var1;
int var4 = var1.length;
for(int var5 = 0; var5 < var4; ++var5) {
CharSequence var6 = var3[var5];
var2.add(var6);
}
return var2.toString();
}
public StringJoiner add(CharSequence var1) {
this.prepareBuilder().append(var1);
return this;
}
//底层依然是Stringbuilder的append方法
private StringBuilder prepareBuilder() {
if (this.value != null) {
this.value.append(this.delimiter);
} else {
this.value = (new StringBuilder()).append(this.prefix);
}
return this.value;
}
1）如果被拼接或拼接的字符串是 null，join 时候就会抛出NullPointerException
2）join底层依然是Stringbuilder的append方法。
总结：
一次字符串拼接 +也是可以的，和StringBuilder没两样
多次拼接字符串，避免使用+。StringBuilder多次append效率更高
