gl分析 每次CR提的String +拼接怎么就不行？

由于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."":()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."":()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."":()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效率更高