In Java, gli oggetti String sono immutabili — una volta creati, i loro contenuti non possono mai cambiare. Qualsiasi operazione che sembra modificare una String crea in realtà una nuova String. Per modificare efficientemente una stringa ripetutamente, si usa StringBuilder.
;
s.concat();
System.out.println(s);
s = s + ;
Metodi come concat, toUpperCase, replace e substring restituiscono tutti nuovi oggetti String — l'originale non viene mai modificato.
✓ 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
L'immutabilità rende le String intrinsecamente thread-safe, consente alla JVM di eseguire interning (condivisione) dei letterali tramite il String pool, e le rende affidabili come chiavi di mappa (il loro hash non cambia mai).
// ❌ 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
}
Poiché ogni += crea una nuova String (copiando tutto il contenuto precedente), costruire stringhe in un ciclo è quadratico e produce una quantità enorme di 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 è una sequenza di caratteri mutabile — append/insert/delete modificano il suo buffer interno senza creare nuovi oggetti, rendendo efficiente la costruzione basata su cicli. (StringBuffer è la variante thread-safe ma più lenta.)
L'immutabilità delle String è una caratteristica distintiva di Java con conseguenze importanti: fornisce thread safety, abilita il string pool che risparmia memoria, e rende le String sicure come chiavi di mappa e in contesti di sicurezza — ma significa anche che la concatenazione ingenua di stringhe nei cicli è una vera trappola di performance (O(n²), garbage eccessivo).
Sapere di usare StringBuilder per modifiche ripetute è una necessità pratica che deriva direttamente dalla comprensione dell'immutabilità.
Questa combinazione — il perché le String sono immutabili (sicurezza, condivisione, hashing) e il quando passare a StringBuilder (concatenazione in cicli) — è sia un argomento frequente nei colloqui che una correzione di performance frequente nel mondo reale.