Java: What is the difference between String, StringBuilder, and StringBuffer?

String — immutable (cannot be changed). StringBuilder — mutable, fast, NOT thread-safe. StringBuffer — mutable, thread-safe, slower.

Analogy: String is like a printed book — once printed, you can't change it. To "modify" it, you print a new book. StringBuilder is like a notebook you can write in freely. StringBuffer is like a shared notebook with a lock — safe for multiple people but slower because of the locking.

String (java.lang.String):

• Immutable — once created, its value cannot change.
• Every "modification" creates a new String object in memory.
• Stored in the String pool (heap memory optimization for literals).
• Thread-safe by nature (immutable = inherently thread-safe).
• Cached hash code — efficient for HashMap/HashSet.
• Bad for repeated concatenation in loops (creates garbage).

1String s = "Hello";
2s = s + " World";  // Creates a NEW String object — "Hello" is discarded
3
4// BAD: String concatenation in a loop (O(n^2) time complexity)
5String result = "";
6for (int i = 0; i < 10000; i++) {
7    result += i + " "; // Each += creates a new String!
8}
9// This creates ~10,000 temporary String objects!

StringBuilder (java.lang.StringBuilder):

• Mutable — modifies itself in place, no new objects.
• Fastest option for single-threaded string building.
• NOT thread-safe (no synchronization overhead).
• Initial capacity: 16 characters (grows by doubling + 2).
• Best for building strings in loops or with many modifications.

1StringBuilder sb = new StringBuilder();
2sb.append("Hello");
3sb.append(" ");
4sb.append("World");
5String result = sb.toString(); // "Hello World"
6
7// Fast: string building in a loop (O(n) time complexity)
8StringBuilder sb2 = new StringBuilder(1000); // pre-size for efficiency
9for (int i = 0; i < 10000; i++) {
10    sb2.append(i).append(" ");
11}
12String result2 = sb2.toString();
13
14// Other useful methods:
15sb.insert(5, "Beautiful ");   // Insert at index
16sb.delete(0, 6);              // Delete range
17sb.replace(0, 5, "Hi");       // Replace range
18sb.reverse();                 // Reverse the string
19sb.charAt(0);                 // Access character
20sb.length();                  // Current length
21sb.capacity();                // Current capacity

StringBuffer (java.lang.StringBuffer):

• Mutable — like StringBuilder, modifies in place.
• Thread-safe — all public methods are synchronized.
• Slower than StringBuilder due to synchronization overhead.
• Use only when multiple threads must modify the same buffer.

1StringBuffer sbf = new StringBuffer();
2sbf.append("Hello");
3sbf.append(" World");
4String result = sbf.toString(); // "Hello World"
5
6// Thread-safe: can be shared between threads
7class SharedBuilder {
8    private StringBuffer buffer = new StringBuffer();
9
10    public synchronized void addLine(String line) {
11        buffer.append(line).append("\n");
12    }
13
14    public String build() {
15        return buffer.toString();
16    }
17}

Performance comparison:

• String concatenation in loops: VERY SLOW (O(n^2)) — avoid!
• StringBuilder: FAST for single-threaded use (O(n)).
• StringBuffer: SLOWER than StringBuilder but thread-safe.

When to use which:

• String — for fixed values, constants, and simple assignments.
• StringBuilder — for building/modifying strings in single-threaded code (99% of cases).
• StringBuffer — only when multiple threads modify the same buffer (rare).

Common mistakes:

• Using + in a loop to build strings (use StringBuilder instead).
• Using StringBuffer when StringBuilder works fine (unnecessary synchronization).
• Not pre-sizing the StringBuilder for large builds (causes multiple resizes).