字符串拼接时到底什么时候进行编译优化

1. 如果两边都是字面量，那么就进行编译优化。

   public class test3 {
       public static void main(String[] args) {
             String c="1"+"1";
       }
   }

   public class test3 {
       public test3() {
       }
   ​
       public static void main(String[] args) {
           String c = "11";
       }
   }

2. 如果是变量，那么就要使用StringBuilder进行拼接。

   1. public class test3 {
          public static void main(String[] args) {
                String a="1";
                String b="1";
                String c=a+b;
          }
      }

      反编译之后验证确实如此

      public class test3 {
          public test3() {
          }
      ​
          public static void main(String[] args) {
              String a = "1";
              String b = "1";
              (new StringBuilder()).append(a).append(b).toString();
          }
      }

3. 是常量引用，也可能会进行编译优化。

   1. 编译时常量引用。比如

      class a{
          public static final String a="1";
          public static final String b="1";
      }
      ​
      public class test3 {
          public static void main(String[] args) {
               String c=a.a+a.b;
          }
      }

      经过反编译之后就是

      public class test3 {
          public test3() {
          }
      ​
          public static void main(String[] args) {
              String c = "11";
          }
      }

      很明显经过了编译优化，但是这个也只限定与编译时常量，运行时常量是不会发生编译优化的，比如

      class A{
          public  final String a="1";
          public  final String b="1";
      }
      ​
      public class test3 {
          public static void main(String[] args) {
              A a = new A();
              String c=a.a+a.b;
          }
      }

      反编译之后发现，没有发生变异优化。

      public class test3 {
          public test3() {
          }
      ​
          public static void main(String[] args) {
              A a = new A();
              StringBuilder var10000 = new StringBuilder();
              a.getClass();
              var10000 = var10000.append("1");
              a.getClass();
              String c = var10000.append("1").toString();
          }
      }

      还有一种情况是局部变量使用final修饰，也视为编译时常量。比如。

      public class test3 {
          public static void main(String[] args) {
              final  String a="1";
              final  String b="1";
              String c=a+b;
          }
      }

      反编译之后发现，发生了编译优化。

      public class test3 {
          public test3() {
          }
      ​
          public static void main(String[] args) {
              String a = "1";
              String b = "1";
              String c = "11";
          }
      }