Java StringBuilder and StringBuffer: Mutable Strings, Methods and Performance

These are the notes for Java episode 10. You will learn why s = s + i in a loop is slow (we time it live with System.currentTimeMillis()), what a StringBuilder is (text you can change in place), its methods append, insert, replace, delete, deleteCharAt, setCharAt and reverse, method chaining, a one-line palindrome check, three StringBuilder traps, capacity and how a builder grows, and StringBuffer, the synchronized twin for many threads. Every example below runs as-is in the SyntaxPilot compiler, with its real output from javac 21 (timings vary from machine to machine and run to run).

The problem: every ticket number in one line

The college fest sold 50,000 tickets, numbered from 0. The gate scanner wants them all in one line: 0,1,2,3,.... The obvious way, from episode 9, is s = s + i + "," in a loop. This time we also time it.

System.currentTimeMillis() returns the current time in milliseconds (thousandths of a second) as a long. Take it before and after, and subtract.

public class Main {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i < 50000; i++) {
            s = s + i + ",";
        }
        long end = System.currentTimeMillis();
        System.out.println("String: " + (end - start) + " ms, " + s.length() + " chars");
    }
}

String: 1405 ms, 288890 chars

Well over a second for one String. With 100,000 tickets it took about 5,200 ms on the same machine: double the work, roughly four times the time.

Why: Strings are immutable. Every + builds a new String and copies every old character into it. Round 1 copies 2 characters, round 2 copies 4, ..., round 50,000 copies about 289,000. Added up, the loop copies billions of characters just to throw them away. The cost grows with the square of the number of rounds.

The fix: StringBuilder

Real-life example: a whiteboard.

Mutable means "can be changed after it's created".

public class Main {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 50000; i++) {
            sb.append(i).append(",");
        }
        String s = sb.toString();
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder: " + (end - start) + " ms, " + s.length() + " chars");
    }
}

StringBuilder: 11 ms, 288890 chars

The same 288,890 characters, more than a hundred times faster. append writes at the end of the existing text without copying it.

Method chaining: append returns the same builder, so you can call the next method straight on it: sb.append(i).append(",").

Note: StringBuilder lives in java.lang, like String, so it needs no import.

StringBuilder methods

Like substring, ranges are start included, end excluded. Every editing method changes the builder itself and returns it (so they chain).

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("chai");
        sb.append(" 20");
        System.out.println(sb);
        sb.insert(0, "Masala ");
        System.out.println(sb);
        sb.replace(12, 14, "25");
        System.out.println(sb);
        sb.delete(0, 7);
        System.out.println(sb);
        sb.setCharAt(0, 'C');
        System.out.println(sb + " | length " + sb.length());
    }
}

chai 20
Masala chai 20
Masala chai 25
chai 25
Chai 25 | length 7

 M a s a l a _ c h a i _ 2 0
 0 1 2 3 4 5 6 7 8 9 ...  12 13      replace(12, 14, "25") swaps index 12 and 13

println(sb) works directly because println calls toString() for us; so does sb + " | ...".

Palindrome check in one line

public class Main {
    public static void main(String[] args) {
        String[] words = {"madam", "level", "java"};
        for (String w : words) {
            String back = new StringBuilder(w).reverse().toString();
            System.out.println(w + " -> " + back + " : " + w.equals(back));
        }
    }
}

madam -> madam : true
level -> level : true
java -> avaj : false

new StringBuilder(w) makes a builder holding a copy of w; reversing it never changes w.

Three StringBuilder traps

1. A StringBuilder is not a String

StringBuilder sb = new StringBuilder("Priya");
String name = sb;

Main.java:4: error: incompatible types: StringBuilder cannot be converted to String
        String name = sb;
                      ^
1 error

Fix: String name = sb.toString();

2. equals on two builders compares objects, not text

public class Main {
    public static void main(String[] args) {
        StringBuilder a = new StringBuilder("chai");
        StringBuilder b = new StringBuilder("chai");
        System.out.println(a.equals(b));
        System.out.println(a.toString().equals(b.toString()));
        System.out.println(a.compareTo(b) == 0);
    }
}

false
true
true

String overrides equals to compare characters; StringBuilder doesn't, so its equals only asks "same object?". Compare toString()s, or use compareTo (Java 11+), which returns 0 when the text is the same.

3. Two names, one builder

public class Main {
    public static void main(String[] args) {
        StringBuilder order = new StringBuilder("tea");
        StringBuilder copy = order;
        copy.append(" + bun");
        System.out.println(order);
    }
}

tea + bun

copy = order copies the reference, as with arrays in episode 7. Both names point to one builder. With Strings this never hurts, because nobody can change a String; with a mutable object, it does. A real copy: new StringBuilder(order).

Capacity: how a StringBuilder grows

Real-life example: a notebook with spare pages.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println(sb.length() + " / " + sb.capacity());
        sb.append("Registration desk");
        System.out.println(sb.length() + " / " + sb.capacity());
        StringBuilder big = new StringBuilder(1000);
        System.out.println(big.length() + " / " + big.capacity());
    }
}

0 / 16
17 / 34
0 / 1000

17 characters didn't fit in 16, so the builder grew to 16 × 2 + 2 = 34. Growing copies the text, but only now and then (each time the room doubles), not on every append like String +. If you know roughly how big the text will be, ask for that capacity up front: new StringBuilder(1000).

StringBuffer: the synchronized twin

A thread is one job a program runs at the same time as other jobs (like two gate scanners writing to one log). We build threads later in the course.

• If two threads append to one StringBuilder at the same moment, characters can get mixed up or lost: StringBuilder is not thread safe.
• StringBuffer has the same methods, but every method is synchronized: it takes a lock, so only one thread can use the buffer at a time. That makes it thread safe.
• The lock costs a little speed. Use StringBuilder for one thread (almost always), StringBuffer when many threads share one text.

public class Main {
    public static void main(String[] args) {
        StringBuffer log = new StringBuffer();
        log.append("Gate 1 open").append(" | ").append("Gate 2 open");
        log.reverse().reverse();
        System.out.println(log + " | length " + log.length());
    }
}

Gate 1 open | Gate 2 open | length 25

Note: for a single line like "Hi " + name + "!", the compiler already does the joining efficiently. StringBuilder matters when you add in a loop or edit text many times.

Common mistakes (and the real error messages)

Mini project: chai stall bill

public class Main {
    public static void main(String[] args) {
        String[] items = {"Masala chai", "Samosa", "Bun maska"};
        int[] qty = {2, 3, 1};
        int[] price = {20, 15, 30};
        StringBuilder bill = new StringBuilder("--- Raju Chai Stall ---\n");
        int total = 0;
        for (int i = 0; i < items.length; i++) {
            int cost = qty[i] * price[i];
            total += cost;
            bill.append(items[i]).append(" x").append(qty[i]).append(" = Rs ").append(cost).append("\n");
        }
        bill.append("Total: Rs ").append(total);
        System.out.println(bill);
    }
}

--- Raju Chai Stall ---
Masala chai x2 = Rs 40
Samosa x3 = Rs 45
Bun maska x1 = Rs 30
Total: Rs 115

\n is the new line escape: it ends the line inside the text. Extend it: add 5% GST on the total, and a "Thank you, visit again!" line.

Practice

1. Build 1-2-3-...-20 with no dash at the end.
2. Remove all spaces from a sentence using deleteCharAt.
3. Hide an email with setCharAt: priya@gmail.com → p****@gmail.com.
4. Time String + vs StringBuilder for 20,000 rounds on your machine.
5. Reverse each word of a sentence but keep the word order: chai is hot → iahc si toh.

Quick quiz

What does this print?

StringBuilder sb = new StringBuilder("abc");
sb.append("d").reverse();
System.out.println(sb + " " + sb.length());

• A. abcd 4
• B. dcba 4
• C. dcba 3
• D. abc 3

Interview questions

1. String vs StringBuilder vs StringBuffer? String is immutable; StringBuilder is mutable and not synchronized (fastest); StringBuffer is mutable and synchronized (thread safe).
2. Why is String concatenation in a loop slow? Each + creates a new String and copies all previous characters: O(n²) total work.
3. What is the default capacity of a StringBuilder, and how does it grow? 16; when full it grows to about (old × 2) + 2.
4. Does StringBuilder.equals compare content? No; it's inherited from Object and compares references.
5. Which was added later, StringBuilder or StringBuffer, and why? StringBuilder, in Java 5, as a faster unsynchronized version for the common single-thread case.
6. Is "a" + b + "c" on one line slow? No; the compiler handles single expressions efficiently. The problem is repeated += in a loop.
7. How do you convert a StringBuilder to a String? sb.toString() (or String.valueOf(sb)).

Glossary

Summary

• s = s + x in a loop copies everything every time: slow (it grows with the square of the rounds).
• StringBuilder is mutable text: append, insert, replace, delete, deleteCharAt, setCharAt, reverse change it in place, and they chain.
• toString() turns it into a String; a builder's equals compares objects, not text.
• Capacity starts at 16 and grows to about double; ask for more up front if you know the size.
• StringBuffer: same methods, synchronized, for text shared by many threads.

Next episode: Methods: write the steps once, give them a name, use them everywhere. Plus pass-by-value and overloading.