Es la concatenación de cadenas en la asignación eficiente?

MetallicPriest:

Yo sé que el uso del operador de concatenación "+" para la construcción de cadenas es muy ineficiente, y es por eso que se recomienda utilizar la clase StringBuilder, pero me preguntaba si este tipo de patrón es ineficaz también?

String some = a + "\t" + b + "\t" + c + "\t" + d + "\t" + e;

Creo que aquí el compilador optimizar la asignación bien, o no?

Charles Dowbecki:

Este ejemplo particular se inlined por el compilador:

String a = "a";
String b = "bb";
String c = "ccc";
String some = a + "\t" + b + "\t" + c;

Java 9+ se inline esto utilizando invokedynamic con makeConcatWithConstants por lo que es eficiente. De acuerdo con javap -vla salida:

Code:
  stack=3, locals=5, args_size=1
     0: ldc           #2                  // String a
     2: astore_1
     3: ldc           #3                  // String bb
     5: astore_2
     6: ldc           #4                  // String ccc
     8: astore_3
     9: aload_1
    10: aload_2
    11: aload_3
    12: invokedynamic #5,  0              // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
    17: astore        4
    19: return

Sin embargo, si el a by cson constantes de tiempo de compilación compilador optimizar aún más el código:

final String a = "a";
final String b = "bb";
final String c = "ccc";
String some = a + "\t" + b + "\t" + c;

y someserá cargado con un valor constante:

Code:
  stack=1, locals=5, args_size=1
     0: ldc           #2                  // String a
     2: astore_1
     3: ldc           #3                  // String bb
     5: astore_2
     6: ldc           #4                  // String ccc
     8: astore_3
     9: ldc           #5                  // String a\tbb\tccc
    11: astore        4
    13: return

En otras circunstancias, por ejemplo foren bucle el compilador podría no ser capaz de producir código optimizado por lo que StringBuilderpuede ser más rápido.