String vs StringBuffer vs StringBuilder

Three ways to hold text

Java has three classes for text: String, StringBuilder and StringBuffer. They differ in whether they can change (mutability), how fast they are, and whether they are thread-safe. Choosing the right one matters when you build or edit a lot of text.

String — immutable

String s = "Hello";
s = s + " World";     // creates a NEW string each time

A String cannot be changed. Every + makes a brand-new String object. That is fine for a few joins, but slow if you do it many times in a loop.

StringBuilder — fast and mutable

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
sb.append("!");
System.out.println(sb.toString());

StringBuilder changes the same object in place with append() — no new objects each time. It is the fast, standard choice for building strings, especially inside loops.

StringBuffer — thread-safe

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World");
System.out.println(sb.toString());

StringBuffer works just like StringBuilder but its methods are synchronized, making it safe when several threads edit the same object. That safety makes it a little slower.

Why performance differs

// slow: new String every loop turn
String s = "";
for (int i = 0; i < 1000; i++) s += i;

// fast: one object, edited in place
StringBuilder b = new StringBuilder();
for (int i = 0; i < 1000; i++) b.append(i);

The String loop creates a thousand throwaway objects; the StringBuilder loop reuses one. For heavy text-building, this difference is huge.

Comparison

Common mistakes

• Using String += in a loop. Slow — use StringBuilder.
• Using StringBuffer everywhere. Its thread safety is wasted in single-threaded code; StringBuilder is faster.
• Forgetting toString(). Convert a builder back to a String with toString() when needed.
• Expecting String to change in place. It never does — it is immutable.

Summary

• String is immutable; every change makes a new object.
• StringBuilder is mutable and fast — the default for building text.
• StringBuffer is mutable and thread-safe but slightly slower.
• Use StringBuilder in loops instead of String +=.
• Pick StringBuffer only when multiple threads edit the same text.

Next, revise text basics in Java strings, or apply them in reverse a string.