What is the difference between concatenation using StringBuilder append() method and String "+" operator?

Question

Given the following two code snippets:

StringBuilder sb = new StringBuilder("");
for (int i = 0; i < 5; i++) {
    sb.append("hello ");
}
System.out.println(sb.toString());

and

String ss = "";
for (int i = 0; i < 5; i++) {
    ss += "hello ";
}
System.out.println(ss);

I read that string concatenation using +, uses StringBuffer or StringBuilder's append method. As far as I know, StringBuilder is mutable, so any modification should not create a new instance. String is immutable, so I expect concatenation in a loop should create a new instance every time (5 times over here). But if + is using StringBuffer or StringBuilder's append method, is it really creating a new instance of ss each time in the loop? Also which among the the code snippets will be more efficient?

Answer 1

It used to be the case that some Java bytecode compilers would compile the String concatenation operator (+) to operations on a temporary StringBuilder.

However:

• This was an implementation detail. Though the JLS (in some versions¹) said that it may be optimized in that way, it was never stated that it shall be.
• This is not how more recent OpenJDK Java compilers deal with this. Concatenation expressions are now compiled by the bytecode compiler to invokedynamic calls ... which are then optimized by the JIT compiler.

---

However, your example involves concatenation in a loop. I don't think that JIT compiler in current versions of Java can optimize across multiple loop iterations.

But, that may change too. Indeed, JEP 280 hints that the "indifying" of string concatenations by the bytecode compiler will enable further JIT compiler optimization. That could include optimization of loops like the 2nd version of your example. And if it does change, "hand optimization" to use StringBuilder calls in your source code could actually interfere with the JIT compiler's ability to optimize.

My advice: avoid premature / unnecessary optimization. Unless your application-level profiling tells you that a particular concatenation sequence is a significant bottleneck, leave it alone.

---

^{1 - For example, the Java 18 JLS says: "An implementation may choose to perform conversion and concatenation in one step to avoid creating and then discarding an intermediate String object. To increase the performance of repeated string concatenation, a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created by evaluation of an expression." JLS 15.18.1.}

Answer 2

I'd always use StringBuilder to concatenate strings in a loop. Doing so has several advantages:

1. you are using StringBuilder what is made to do, so it is easier to read (but less concise);
2. you can pass StringBuilder around using method arguments (if you'd use the immutable String you can only use it as return value);
3. StringBuilder has additional options to alter the string if that would be necessary;
4. it will allocate some buffer space in advance, so that subsequent alterations / concatenations don't take that much memory;
5. it can be assumed to be relatively performant whichever direction the current JVM takes when it comes to string concatenation.

---

Of course, I'd use new StringBuilder() instead of the new StringBuilder("") which makes no sense - StringBuilder instances will already start with an empty string (and 16 characters of buffer space).

If you know the size of the string in advance then it does make sense to create a buffer large enough to hold it, so it doesn't need to request a larger area to hold the characters. Memory management is relatively expensive.

With regard to that, note that StringBuilder implements CharSequence so you can actually use it instead of a String for some methods if you want to avoid copies.

Answer 3

"Concatenate" joins two specific items together, whereas "append " adds what you specify to whatever may already be there