In Java zijn String-objecten onveranderbaar — zodra ze zijn gemaakt, kan hun inhoud nooit veranderen. Elke bewerking die een String lijkt te wijzigen, creëert eigenlijk een nieuwe String. Voor efficiënte herhaalde wijzigingen gebruik je in plaats daarvan StringBuilder.
;
s.concat();
System.out.println(s);
s = s + ;
Methoden als concat, toUpperCase, replace en substring retourneren allemaal nieuwe String-objecten — het origineel wordt nooit gewijzigd.
✓ 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
Onveranderbaarheid maakt Strings inherent thread-safe, stelt de JVM in staat literals via de String pool te intern (delen), en maakt ze betrouwbaar als mapsleutels (hun hash verandert nooit).
// ❌ 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
}
Omdat elke += een nieuwe String creëert (alle eerdere inhoud kopieert), is stringbouw in een lus kwadratisch en produceert enorm veel 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 een muteerbare reeks tekens — append/insert/delete wijzigen zijn interne buffer zonder nieuwe objecten aan te maken, waardoor lus-gebaseerde bouw efficiënt is. (StringBuffer is de thread-safe maar langzamere variant.)
String-onveranderbaarheid is een definiërend Java-kenmerk met belangrijke gevolgen: het biedt thread-veiligheid, maakt de geheugenbesparende stringpool mogelijk, en maakt Strings veilig als mapsleutels en in beveiligingscontexten — maar het betekent ook dat naïeve stringconcatenatie in lussen een echt prestatieprobleem is (O(n²), overmatig garbage).
Weten dat je StringBuilder moet gebruiken voor herhaalde wijziging is een praktische noodzaak die rechtstreeks voortvloeit uit het begrijpen van onveranderbaarheid.
Deze combinatie — waarom Strings onveranderbaar zijn (veiligheid, delen, hashing) en wanneer naar StringBuilder moet overschakelen (lupconcatenatie) — is zowel een veelvoorkomend interviewonderwerp als een veelvuldig real-world prestatiesfix.