Java StringBuilder

How StringBuilder Fixes the Memory Problem

Building text with += in a loop looks harmless, but because Strings are immutable each pass creates a brand-new String and copies every character built so far into it. The previous String becomes garbage immediately. For a loop of n steps that is n throwaway objects and a growing amount of copying each time.

A StringBuilder keeps one resizable character array instead. It starts with room for 16 characters, and append() writes straight into the free space. Only when the array is full does it allocate a bigger one — roughly double the size plus two — and copy the contents across once. So thousands of appends cost a handful of allocations rather than thousands, and a single toString() at the end produces the final String.

Same API, No Synchronization

StringBuilder and StringBuffer implement the same CharSequence-based operations and share method signatures almost identically, so switching between them (when thread-safety requirements change) is usually just a matter of changing the type name. The difference is entirely about the synchronized keyword being present on StringBuffer's methods and absent on StringBuilder's.

• append(...) — adds content to the end; returns the same StringBuilder for chaining.
• insert(int offset, ...) — inserts content at a given index.
• delete(int start, int end), deleteCharAt(int index) — remove content.
• reverse() — reverses the sequence in place.
• capacity() — reports the current size of the internal buffer, which grows automatically as needed.

Why the Compiler Prefers It

When you write code like String result = "Total: " + count + " items";, the compiler typically rewrites this internally using a StringBuilder (or similar mechanism) rather than performing several separate String concatenations. This is why simple, single-line concatenation is not actually as wasteful as it might first appear — but building a String across many iterations of a loop with "+" is still inefficient, because a new StringBuilder (or new String) is effectively created on every loop iteration unless you manage one StringBuilder explicitly yourself.

When to Still Use StringBuffer Instead

StringBuilder should not be shared across multiple threads without external synchronization, because concurrent modifications can corrupt its internal state or produce inconsistent results. If multiple threads genuinely need to mutate the same buffer concurrently, StringBuffer (or a higher-level concurrency-safe design) remains the correct choice.

Examples

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i);
            if (i < 5) {
                sb.append(", ");
            }
        }
        System.out.println("Numbers: " + sb.toString());
        System.out.println("Length: " + sb.length());

        sb.insert(0, "[").append("]");
        System.out.println(sb);
    }
}

Numbers: 1, 2, 3, 4, 5
Length: 13
[1, 2, 3, 4, 5]

public class BuilderCapacityDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println(sb.capacity());       // room for 16 characters

        sb.append("0123456789ABCDEF");           // exactly 16 characters
        System.out.println(sb.capacity());       // still 16, no new array needed

        sb.append("G");                          // the 17th character does not fit
        System.out.println(sb.capacity());       // grown to (16 * 2) + 2

        System.out.println(sb.length());         // characters actually stored
    }
}

16
16
34
17

Exercise

Join the elements of an array into one line separated by a comma and a space, with no separator at the end.

Expected output: red, green, blue

public class JoinColours {
    public static void main(String[] args) {
        String[] colours = {"red", "green", "blue"};
        StringBuilder line = new StringBuilder();

        // TODO: append each colour, adding ", " between them but not after the last

        System.out.println(line);
    }
}

public class JoinColours {
    public static void main(String[] args) {
        String[] colours = {"red", "green", "blue"};
        StringBuilder line = new StringBuilder();

        for (int i = 0; i < colours.length; i++) {
            if (i > 0) {
                line.append(", ");
            }
            line.append(colours[i]);
        }

        System.out.println(line); // red, green, blue
    }
}

Quick quiz

Interview questions