¿Qué sucede cuando el compilador Java ve muchas concatenaciones de cadenas en una línea?

Question

Supongamos que tengo una expresión en Java, tales como:

String s = "abc" + methodReturningAString() + "ghi" + 
       anotherMethodReturningAString() + "omn" + "blablabla"; 

¿Cuál es el comportamiento por defecto del JDK de Java compilador? ¿Hace las cinco concatenaciones o hay un truco de rendimiento inteligente hecho?

Answer 1

genera el equivalente de:

String s = new StringBuilder("abc") 
      .append(methodReturningAString()) 
      .append("ghi") 
      .append(anotherMethodReturningAString()) 
      .append("omn") 
      .append("blablabla") 
      .toString(); 

Es lo suficientemente inteligente como para pre-concatenar cadenas estáticas (es decir, el "omn" + "blablabla"). Puede llamar al uso de StringBuilder un "truco de rendimiento" si lo desea. Definitivamente es mejor para el rendimiento que hacer cinco concatenaciones que resultan en cuatro cadenas temporales innecesarias. Además, el uso de StringBuilder fue una mejora en el rendimiento en (creo) Java 5; antes de eso, se usó StringBuffer.

Editar: como se señala en los comentarios, las cadenas estáticas solo se concatenan previamente si están al comienzo de la concatenación. Hacer lo contrario rompería el orden de las operaciones (aunque en este caso creo que Sun podría justificarlo). Así que dado esto:

String s = "abc" + "def" + foo() + "uvw" + "xyz"; 

sería compilado la siguiente manera:

String s = new StringBuilder("abcdef") 
      .append(foo()) 
      .append("uvw") 
      .append("xyz") 
      .toString();