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

Question

Accepted Answer

**String** — immutable (can't change). **StringBuilder** — mutable, fast, single-threaded. **StringBuffer** — mutable, thread-safe, slower.

Analogy: **String** is like a printed book — once printed, you can't edit it. To change it, you print a new book. **StringBuilder** is like a whiteboard — you can write, erase, and rewrite freely. **StringBuffer** is like a whiteboard with a lock — safe for multiple people, but the lock slows you down.

**String:**
- **Immutable** — every change creates a new object.
- Stored in the **String pool** (memory optimization).
- Thread-safe by nature (immutable = inherently thread-safe).
- Cached hash code — efficient for HashMap/HashSet.

```java
String s = "Hello";
s = s + " World"; // Creates NEW String — "Hello" is garbage

// BAD: concatenation in loops (O(n^2) time!)
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i + " "; // Creates ~10,000 temporary objects!
}

// GOOD: use StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i).append(" ");
}
String result2 = sb.toString();
```

**StringBuilder:**
- **Mutable** — modifies in place, no new objects.
- **Fastest** for single-threaded string building.
- NOT thread-safe (no synchronization).
- Default capacity: 16, grows by doubling + 2.

```java
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString(); // "Hello World"

// Useful methods:
sb.insert(5, "Beautiful "); // Insert at index
sb.delete(0, 6);            // Delete range
sb.replace(0, 5, "Hi");     // Replace range
sb.reverse();               // Reverse
sb.charAt(0);               // Access character
sb.length();                // Current length
sb.capacity();              // Current capacity

// Pre-size for efficiency:
StringBuilder big = new StringBuilder(10000);
```

**StringBuffer:**
- **Mutable** — like StringBuilder.
- **Thread-safe** — all methods are `synchronized`.
- Slower than StringBuilder due to synchronization.
- Use only when multiple threads modify the same buffer.

```java
StringBuffer sbf = new StringBuffer();
sbf.append("Hello");
sbf.append(" World");
String result = sbf.toString(); // "Hello World"

// Thread-safe shared buffer
class ThreadSafeLogger {
    private StringBuffer buffer = new StringBuffer();

public void log(String message) {
        buffer.append(message).append("
");
    }

public String getLogs() {
        return buffer.toString();
    }
}
```

**Performance:**
- String concatenation in loops: SLOW (O(n^2)).
- StringBuilder: FASTEST for single-threaded (O(n)).
- StringBuffer: SLOWER but thread-safe.

**When to use:**
- **String** — fixed values, constants, simple assignments.
- **StringBuilder** — building strings in loops (99% of cases).
- **StringBuffer** — only when multiple threads modify the same buffer (rare).

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