How Java's + Operator Works for Strings

Direct Answer

String + is a language feature, not a guaranteed StringBuilder rewrite. Compile-time constant string expressions are folded and interned. For runtime concatenation, modern javac commonly emits invokedynamic and StringConcatFactory; the JVM chooses an efficient recipe. Repeatedly extending a growing String in a loop can still copy earlier text, so use one StringBuilder for that pattern.

Code Example

public class PlusOperatorDemo {
    public static void main(String[] args) {
        String name = "World";

        // Single-line — compiler rewrites to StringBuilder chain, efficient
        String greeting = "Hello, " + name + "!";
        // Roughly becomes: new StringBuilder().append("Hello, ").append(name).append("!").toString()
        System.out.println(greeting); // Hello, World!

        // Loop — compiler CANNOT merge iterations, creates new object per iteration
        String[] words = {"Java", " is", " powerful"};
        String slow = "";
        for (String w : words) {
            slow = slow + w;  // new StringBuilder + new String each time
        }

        // Correct approach — create StringBuilder once before the loop
        StringBuilder sb = new StringBuilder();
        for (String w : words) {
            sb.append(w);  // write to same buffer every time
        }
        String fast = sb.toString();  // one String at the very end
        System.out.println(fast); // Java is powerful
    }
}

Common Mistakes & Pitfalls

• Believing the compiler optimises + inside loops — it only rewrites a single expression; it cannot merge iterations, so result = result + word in a loop is genuinely O(n²), not the efficient StringBuilder chain people assume.
• Using String += to build large strings — every += allocates a new StringBuilder and a new String; for thousands of items this shows up as real CPU and GC pressure. Use one StringBuilder.
• Calling toString() inside the loop — even with a manual StringBuilder, materialising the string every iteration throws away the benefit; call toString() exactly once after the loop.
• Assuming StringBuffer is the answer for performance — StringBuffer is synchronized and slower; in single-threaded code (the common case) StringBuilder is the right choice.