String vs StringBuffer vs StringBuilder

String, StringBuffer, and StringBuilder all represent sequences of characters, but they differ fundamentally in mutability and thread-safety, and choosing the right one for a given situation is a common Java design decision — and a frequent interview question.

Why it matters

Choosing between these three types is a decision you make constantly, usually without thinking. The right default is simple — String for values, StringBuilder for building — but you should be able to explain why, because "String vs StringBuffer vs StringBuilder" is asked in nearly every Java interview for junior roles.

Mutability: The Core Difference

String is immutable: every "modification" produces a brand-new object, leaving the original unchanged. StringBuffer and StringBuilder are both mutable: they maintain an internal, resizable character buffer that is changed directly by methods like append() and insert(), without creating a new object each time. This is why building a large piece of text with String concatenation in a loop is inefficient compared to using StringBuffer or StringBuilder — the loop would otherwise create one throwaway String object per iteration.

Thread Safety and Performance

StringBuffer's methods are synchronized, making a single instance safe to mutate from multiple threads, but that safety costs performance due to lock acquisition on every call. StringBuilder offers the identical API without synchronization, making it faster in single-threaded contexts — which describes the vast majority of string-building code — but unsafe to share across threads without external coordination.

• String: immutable, inherently thread-safe (nothing can change), best for fixed or rarely-changing text and as map/set keys.
• StringBuffer: mutable, synchronized (thread-safe), best when multiple threads must modify the same buffer.
• StringBuilder: mutable, not synchronized, best for single-threaded string building — the usual default.

Choosing the Right One

As a practical rule: use String for values that do not change or change rarely, use StringBuilder when you need to build or transform text repeatedly within one thread (loops, parsing, formatting), and reach for StringBuffer only in the specific case where the same mutable buffer genuinely must be shared and modified by multiple threads concurrently.

Time complexity

Example

public class StringComparisonDemo {
    public static void main(String[] args) {
        // String: each += creates a new object (fine for a handful of operations)
        String s = "";
        for (int i = 0; i < 3; i++) {
            s += i;
        }
        System.out.println("String result: " + s);

        // StringBuilder: one buffer, modified in place, no synchronization
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 3; i++) {
            sb.append(i);
        }
        System.out.println("StringBuilder result: " + sb);

        // StringBuffer: one buffer, modified in place, synchronized (thread-safe)
        StringBuffer sbf = new StringBuffer();
        for (int i = 0; i < 3; i++) {
            sbf.append(i);
        }
        System.out.println("StringBuffer result: " + sbf);
    }
}

String result: 012
StringBuilder result: 012
StringBuffer result: 012

Exercise

This program builds its result with String concatenation in a loop. Rewrite it to use a StringBuilder. The output must stay the same.

Expected output: 12345

public class BuildDigits {
    public static void main(String[] args) {
        String result = "";

        for (int i = 1; i <= 5; i++) {
            result += i;
        }

        System.out.println(result);
    }
}

public class BuildDigits {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();

        for (int i = 1; i <= 5; i++) {
            builder.append(i);
        }

        String result = builder.toString();
        System.out.println(result); // 12345
    }
}

Quick quiz

Interview questions