In Java, String objects are immutable — once created, their contents can never change. Any operation that appears to modify a String actually creates a new String. For efficient repeated modification, you use StringBuilder instead.
;
s.concat();
System.out.println(s);
s = s + ;
Methods like concat, toUpperCase, replace, and substring all return new String objects — the original is never modified.
✓ Thread safety — immutable objects are safe to share across threads (no locking)
✓ String pool — identical string literals can be SHARED/reused (memory savings)
✓ Hashing/keys — safe as HashMap keys (hashCode can be cached, never changes)
✓ Security — strings used for filenames, URLs, credentials can't be altered
after a security check
Immutability makes Strings inherently thread-safe, allows the JVM to intern (share) literals via the String pool, and makes them reliable as map keys (their hash never changes).
// ❌ creates a NEW string object on EVERY iteration — O(n²), wasteful
String result = "";
for (int i = 0; i < 10000; i++) {
result += i; // each += allocates a whole new string
}
Because each += creates a new String (copying all prior content), building strings in a loop is quadratic and produces tons of garbage.
// ✅ StringBuilder mutates an internal buffer — O(n), efficient
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.append(i); // modifies the buffer in place, no new objects
}
String result = sb.toString(); // convert to a String once, at the end
StringBuilder is a mutable sequence of characters — append/insert/delete modify its internal buffer without creating new objects, making loop-based building efficient. (StringBuffer is the thread-safe but slower variant.)
String immutability is a defining Java characteristic with important consequences: it provides thread safety, enables the memory-saving string pool, and makes Strings safe as map keys and in security contexts — but it also means naive string concatenation in loops is a real performance pitfall (O(n²), excessive garbage).
Knowing to use StringBuilder for repeated modification is a practical necessity that comes directly from understanding immutability.
This combination — why Strings are immutable (safety, sharing, hashing) and when to switch to StringBuilder (loop concatenation) — is both a common interview topic and a frequent real-world performance fix.