1. The Hook (The "Byte-Sized" Intro)
In a Nutshell: StringBuilder provides mutable character sequences. Unlike String, modifications happen in-place without creating new objects—crucial for loops and concatenation.
When Slack builds message previews: sb.append(sender).append(": ").append(preview). No memory waste!
2. Conceptual Clarity
String vs StringBuilder
3. Quick Reference
| Method | Returns | Purpose |
|---|---|---|
append(x) | StringBuilder | Add to end |
insert(pos, x) | StringBuilder | Insert at position |
delete(start, end) | StringBuilder | Remove range |
reverse() | StringBuilder | Reverse characters |
replace(start, end, str) | StringBuilder | Replace range |
toString() | String | Convert to String |
4. Interactive & Applied Code
public class StringBuilderDemo {
public static void main(String[] args) {
// === CREATION ===
StringBuilder sb = new StringBuilder(); // Empty
StringBuilder sb2 = new StringBuilder("Hello"); // With initial
StringBuilder sb3 = new StringBuilder(100); // With capacity
// === APPEND (chaining) ===
sb.append("Hello")
.append(" ")
.append("World")
.append("!");
System.out.println(sb); // "Hello World!"
// === INSERT ===
sb.insert(6, "Beautiful ");
System.out.println(sb); // "Hello Beautiful World!"
// === DELETE ===
sb.delete(6, 16); // Remove "Beautiful "
System.out.println(sb); // "Hello World!"
// === REVERSE ===
StringBuilder rev = new StringBuilder("Java");
rev.reverse();
System.out.println(rev); // "avaJ"
// === REPLACE ===
StringBuilder r = new StringBuilder("Hello World");
r.replace(6, 11, "Java");
System.out.println(r); // "Hello Java"
// === PERFORMANCE: Loop concatenation ===
// ❌ BAD: Creates N string objects
String bad = "";
for (int i = 0; i < 10000; i++) {
bad += i; // O(N²) - copies entire string each time!
}
// ✅ GOOD: One StringBuilder, N appends
StringBuilder good = new StringBuilder();
for (int i = 0; i < 10000; i++) {
good.append(i); // O(N) - amortized
}
String result = good.toString();
// === CAPACITY MANAGEMENT ===
StringBuilder cap = new StringBuilder(50); // Initial capacity
System.out.println("Capacity: " + cap.capacity()); // 50
System.out.println("Length: " + cap.length()); // 0
cap.ensureCapacity(100); // Grow if needed
// === REAL-WORLD: Building HTML ===
StringBuilder html = new StringBuilder();
html.append("<ul>\n");
String[] items = {"Apple", "Banana", "Cherry"};
for (String item : items) {
html.append(" <li>").append(item).append("</li>\n");
}
html.append("</ul>");
System.out.println(html);
// === REAL-WORLD: CSV builder ===
StringBuilder csv = new StringBuilder();
int[] values = {1, 2, 3, 4, 5};
for (int i = 0; i < values.length; i++) {
csv.append(values[i]);
if (i < values.length - 1) csv.append(",");
}
System.out.println(csv); // "1,2,3,4,5"
}
}⚠️ Common Mistakes
Mistake #1: Not using StringBuilder in loops
// ❌ O(N²) - creates N new strings
String s = "";
for (int i = 0; i < 1000; i++) s += i;
// ✅ O(N) - efficient
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) sb.append(i);Mistake #2: Forgetting toString()
StringBuilder sb = new StringBuilder("text");
String s = sb; // ❌ Compile error
String s = sb.toString(); // ✅5. The "Interview Corner"
🏆 Q1: "Why is String + in loops O(N²)?"
Answer: Each += creates a new String copying all prior characters. N iterations = N + (N-1) + (N-2) + ... + 1 = O(N²) copies.
🏆 Q2: "Default StringBuilder capacity?" Answer: 16 characters. When exceeded, capacity doubles (automatic resize).
🏆 Q3: "Is StringBuilder thread-safe?"
Answer: No. Use StringBuffer for thread-safety (synchronized methods).
🎓 Key Takeaways
✅ Use StringBuilder for loop concatenation
✅ Mutable—modifications in-place
✅ Chain methods: sb.append().insert().reverse()
✅ Convert with toString() when done
✅ Not thread-safe (use StringBuffer if needed)