Java StringBuffer

How StringBuffer Beats Immutable Strings

A String can never be changed, so every "modification" — concat(), +, replace() — has to allocate a new String object and copy the old characters into it. The original object is left behind for the garbage collector. Do that a thousand times in a loop and you have created a thousand objects to end up with one piece of text.

A StringBuffer works the other way round. It owns one internal character array, and append(), insert() and reverse() write into that same array. No new object is created per change; the buffer only allocates a larger array when it runs out of room. You can see the difference directly: append() returns the very same StringBuffer it was called on, while concat() returns a different String.

Core Mutating Methods

StringBuffer's API is built around modifying its internal buffer directly rather than returning new objects.

• append(...) — adds text to the end of the buffer; overloaded for String, char, int, boolean, and more.
• insert(int offset, ...) — inserts text at a specific position.
• reverse() — reverses the character sequence in place.
• delete(int start, int end) and deleteCharAt(int index) — remove characters from the buffer.
• replace(int start, int end, String str) — replaces a range of characters with new text.

Thread Safety and Its Cost

Every mutating method on StringBuffer is marked synchronized, meaning only one thread can execute a method on a given StringBuffer instance at a time. This guarantees correct behavior when several threads append to the same buffer concurrently, but the locking overhead makes StringBuffer measurably slower than its non-synchronized counterpart, StringBuilder, in single-threaded code — which is the overwhelming majority of real-world use cases.

Converting Back to String

Once you finish building or modifying text with a StringBuffer, call toString() to obtain an immutable String snapshot of the current content. The StringBuffer itself can continue to be reused and modified afterward, independently of any String already produced from it.

Examples

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Java");
        sb.append(" is").append(" powerful");
        System.out.println(sb);

        sb.insert(4, " language");
        System.out.println(sb);

        sb.replace(0, 4, "Kotlin");
        System.out.println(sb);

        sb.reverse();
        System.out.println(sb);
    }
}

Java is powerful
Java language is powerful
Kotlin language is powerful
lufrewop si egaugnal niltoK

public class MutableVsImmutable {
    public static void main(String[] args) {
        String text = "Java";
        String changed = text.concat(" 17");
        System.out.println(text == changed); // different objects
        System.out.println(text);            // the original is untouched

        StringBuffer buffer = new StringBuffer("Java");
        StringBuffer same = buffer.append(" 17");
        System.out.println(buffer == same);  // the same object
        System.out.println(buffer);          // it was modified in place
    }
}

false
Java
true
Java 17

Exercise

Build the text 1-2-3-4-5 with a StringBuffer and a loop, making sure there is no dash at the end.

Expected output: 1-2-3-4-5

public class DashList {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer();

        // TODO: append the numbers 1 to 5 separated by dashes, with no trailing dash

        System.out.println(buffer);
    }
}

public class DashList {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer();

        for (int i = 1; i <= 5; i++) {
            buffer.append(i).append('-');
        }
        buffer.deleteCharAt(buffer.length() - 1);

        System.out.println(buffer); // 1-2-3-4-5
    }
}

Quick quiz

Interview questions