I Java är String-objekt immutable — när de väl skapats kan deras innehål aldrig förändras. Alla operationer som verkar modifiera en String skapar faktiskt en ny String. För effektiv upprepad modifiering använder du StringBuilder istället.
;
s.concat();
System.out.println(s);
s = s + ;
Metoder som concat, toUpperCase, replace och substring returnerar alla nya String-objekt — originalet modifieras aldrig.
✓ 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 gör Strings trådsakra av naturen, låter JVM att internen (dela) literaler via String-poolen, och gör dem pålitliga som mappnyckar (deras hash ändras aldrig).
// ❌ 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 varje += skapar en ny String (kopierar allt tidigare innehål), blir byggnation av strängar i en loop kvadratisk och producerar massor av 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 är en mutbar sekvens av tecken — append/insert/delete modifierar dess interna buffert utan att skapa nya objekt, vilket gör loopbaserad byggnation effektiv. (StringBuffer är varianten som är trådsakra men långsammare.)
String-immutability är en definerande Java-egenskap med viktiga konsekvenser: den ger trådsäkerhet, möjliggör den minnesbesparande strängpoolen, och gör Strings säkra som mappnyckar och i säkerhetskontexster — men det betyder också att naiv strängsammansättning i loopar är en verklig prestandafälla (O(n²), överflödig garbage).
Att veta när man ska använda StringBuilder för upprepad modifiering är en praktisk nödvändighet som kommer direkt från att förstå immutability.
Denna kombination — varför Strings är immutable (säkerhet, delning, hashing) och när man ska byta till StringBuilder (loopsammansättning) — är både ett vanligt intervjuämne och en ofta förekommande prestandafix i verklig världen.