What happens when Java Compiler sees many String concatenations in one line?

Question

Suppose I have an expression in Java such as:

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

What's the behaviour of the Java's default JDK compiler? Does it just makes the five concatenations or there is a smart performance trick done?

Answer 1

It generates the equivalent of:

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

It is smart enough to pre-concatenate static strings (i.e. the "omn" + "blablabla"). You could call the use of StringBuilder a "performance trick" if you want. It is definitely better for performance than doing five concatenations resulting in four unnecessary temporary strings. Also, use of StringBuilder was a performance improvement in (I think) Java 5; prior to that, StringBuffer was used.

Edit: as pointed out in the comments, static strings are only pre-concatenated if they are at the beginning of the concatenation. Doing otherwise would break order-of-operations (although in this case I think Sun could justify it). So given this:

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

it would be compiled like this:

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