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

Question

Accepted Answer

**String** — immutable. **StringBuilder** — mutable, fast. **StringBuffer** — mutable, thread-safe.

Analogy: **String** = printed book (immutable). **StringBuilder** = whiteboard (fast edits). **StringBuffer** = locked whiteboard (safe but slow).

**String:**
- Immutable — new object per change.
- String pool optimization.
- Thread-safe.
- Bad in loops.

```java
String s = "Hello";
s = s + " World"; // New object

// BAD in loops:
String r = "";
for (int i = 0; i < 10000; i++) {
    r += i + " "; // O(n^2)
}

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

**StringBuilder:**
- Mutable — in-place edits.
- Fastest single-threaded.
- Not thread-safe.

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

sb.insert(5, " ");
sb.delete(0, 6);
sb.reverse();
sb.charAt(0);
sb.length();
sb.capacity();

// Pre-size:
new StringBuilder(10000);
```

**StringBuffer:**
- Mutable — like StringBuilder.
- Thread-safe — synchronized.
- Slower.

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

// Thread-safe:
class Log {
    private StringBuffer buf = new StringBuffer();
    public void add(String msg) { buf.append(msg).append("
"); }
    public String get() { return buf.toString(); }
}
```

**Performance:** String loops: SLOW. StringBuilder: FASTEST. StringBuffer: slower but safe.

**Use:** String = constants. StringBuilder = loops. StringBuffer = multi-threaded (rare).

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