Concatenazione di Stringhe in Java

"Concatenazione" significa semplicemente unire stringhe una dopo l'altra. Java offre diversi modi per farlo — +, concat, String.format, blocchi di testo, StringBuilder, String.join. Si differenziano per leggibilità e, nei cicli, per prestazioni.

L'operatore +

+ è il metodo più comune:

String first = "Ada";
String last = "Lovelace";
String full = first + " " + last;     // "Ada Lovelace"

Converte anche i non-string in stringhe tramite il loro toString():

int age = 36;
String s = "Age: " + age;             // "Age: 36"

Dietro le quinte, il compilatore trasforma a + b + c in un unico StringBuilder.append(...).append(...).toString(). Quindi un'espressione + concatenata è efficiente.

concat

String.concat(other) restituisce questa stringa seguita da other:

"Hello, ".concat("World!");    // "Hello, World!"

È praticamente identico a +, ma accetta solo una String (nessuna conversione automatica). La maggior parte del codice usa semplicemente +.

String.format e formatted

Per concatenazioni con più parti e formattazione specifica per tipo, String.format è più chiaro rispetto a lunghe catene di +:

String name = "Ada";
int age = 36;
String s = String.format("%s is %d years old", name, age);

Da Java 15, il metodo d'istanza formatted è equivalente e si legge da sinistra a destra:

"%s is %d years old".formatted(name, age);

Blocchi di testo per stringhe multiriga

Per le stringhe multiriga, la sintassi dei blocchi di testo (Java 15+) evita lunghe catene con \n:

String json = """
        {
          "name": "%s",
          "age": %d
        }
        """.formatted(name, age);

StringBuilder — per i cicli

Le stringhe Java sono immutabili — una volta create, una String non può mai cambiare. Quindi ogni + su una String produce un nuovo oggetto. In un ciclo con migliaia di iterazioni, questo genera molti oggetti di breve durata e molte copie. Usa invece StringBuilder — ha un singolo buffer interno mutabile che cresce sul posto:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("line ").append(i).append("\n");
}
String result = sb.toString();

I metodi di StringBuilder che utilizzerai:

• append(any) — aggiunge alla fine (restituisce il builder per poter concatenare le chiamate).
• insert(index, any) — inserisce in una posizione.
• delete(start, end) — rimuove un intervallo.
• reverse() — inverte il contenuto del builder.
• length() e setLength(n) — legge / tronca.
• toString() — produce la String finale.

Esiste anche StringBuffer, identico ma thread-safe (ogni metodo è synchronized). Quasi mai ne avrai bisogno — usa StringBuilder a meno che tu non condivida davvero il builder tra thread.

String.join — per le collezioni

Quando hai una collezione di stringhe e un separatore, String.join è la soluzione più pulita:

String csv = String.join(",", "a", "b", "c");        // "a,b,c"
String csv2 = String.join(", ", List.of("a", "b", "c"));   // "a, b, c"

Per operazioni di unione più avanzate (collector, inclusione condizionale), consulta Collectors.joining degli stream più avanti nel libro.

Quando usare quale

Un albero decisionale approssimativo:

• Uno o due elementi, leggibili da sinistra a destra → +.
• Più elementi con formattazione per tipo → String.format o formatted.
• Letterale multiriga → blocco di testo, opzionalmente con .formatted.
• Costruzione pezzo per pezzo in un ciclo → StringBuilder.
• Unione di una collezione con un separatore → String.join.

Per piccole concatenazioni, i compilatori moderni e la JVM (con la concatenazione di stringhe basata su invokedynamic introdotta in Java 9) rendono + molto veloce — le prestazioni non sono un motivo per evitarlo nei casi semplici.

Una dimostrazione del caso con ciclo

Cosa c'è dopo

Caratteri Speciali e Sequenze di Escape in Java — cosa fanno \n, \t, \" e gli escape Unicode.

Pratica