En Java, les objets String sont immuables — une fois créés, leur contenu ne peut jamais changer. Toute opération qui semble modifier une String crée en réalité une nouvelle String. Pour une modification répétée efficace, vous utilisez StringBuilder à la place.
;
s.concat();
System.out.println(s);
s = s + ;
Les méthodes comme concat, toUpperCase, replace et substring renvoient toutes des objets String nouveaux — l'original n'est jamais modifié.
✓ 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'immuabilité rend les Strings intrinsèquement thread-safe, permet à la JVM d'interner (partager) les littéraux via le pool de Strings, et les rend fiables comme clés de map (leur hash ne change jamais).
// ❌ 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
}
Comme chaque += crée une nouvelle String (en copiant tout le contenu précédent), construire des strings en boucle est quadratique et produit énormément de déchets.
// ✅ 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 est une séquence mutable de caractères — append/insert/delete modifient son buffer interne sans créer de nouveaux objets, rendant la construction basée sur boucles efficace. (StringBuffer est la variante thread-safe mais plus lente.)
L'immuabilité des Strings est une caractéristique déterminante de Java avec des conséquences importantes : elle fournit la thread-safety, permet le pool de Strings qui économise la mémoire, et rend les Strings sûres comme clés de map et dans les contextes de sécurité — mais cela signifie aussi que la concaténation naïve de strings en boucles est un véritable piège de performance (O(n²), garbage excessif).
Savoir utiliser StringBuilder pour une modification répétée est une nécessité pratique qui découle directement de la compréhension de l'immuabilité.
Cette combinaison — pourquoi les Strings sont immuables (sécurité, partage, hachage) et quand passer à StringBuilder (concaténation en boucle) — est à la fois un sujet courant d'entretien et une correction de performance fréquente dans le monde réel.