Stringhe Java

Una String rappresenta una sequenza di caratteri ed è, dopo int, il tipo che utilizzerai più spesso. È una classe (non un tipo primitivo), ma Java le fornisce una sintassi speciale — letterali tra virgolette doppie, l'operatore + per la concatenazione — così il suo utilizzo risulta simile a quello di un tipo primitivo. Il fatto più importante sulle stringhe: sono immutabili.

Questo capitolo spiega come creare stringhe, perché l'immutabilità è importante, come misurarne la lunghezza e accedere ai caratteri per indice, come confrontarle correttamente, i metodi più comuni, la concatenazione, i blocchi di testo multiriga e la formattazione.

Creare una stringa

Il modo più semplice è usare un letterale stringa tra virgolette doppie:

String greeting = "Hello, World!";
String empty = "";
String multi = "Line 1\nLine 2";   // \n is a newline

Puoi anche costruirne una con new, anche se raramente è necessario:

String fromLiteral = "Hello";
String fromNew = new String("Hello");

new String(...) alloca sempre un oggetto nuovo. I letterali vengono messi in pool — due letterali con gli stessi caratteri sono lo stesso oggetto. Questo è rilevante per i confronti con == ma non per altro; dovresti comunque usare sempre .equals() per confrontare i contenuti.

Le stringhe sono immutabili

Una volta creata una String, il suo contenuto non cambia mai. Ogni metodo che "modifica" una stringa in realtà restituisce una nuova stringa:

String s = "hello";
s.toUpperCase();
System.out.println(s);   // "hello" — unchanged

s = s.toUpperCase();
System.out.println(s);   // "HELLO" — new string assigned

L'immutabilità ha diversi vantaggi:

• Sicura da condividere tra thread — nessuna sincronizzazione necessaria.
• L'hash code può essere memorizzato nella cache.
• Le stringhe possono essere usate in sicurezza come chiavi nelle mappe.

Il compromesso: costruire una stringa lunga in un ciclo con + crea molte stringhe intermedie. Per questo, usa StringBuilder (Concatenazione di Stringhe).

Lunghezza e indicizzazione

length() restituisce il numero di caratteri:

String s = "hello";
System.out.println(s.length());   // 5

charAt(i) restituisce il carattere all'indice i (a base zero):

System.out.println(s.charAt(0));   // 'h'
System.out.println(s.charAt(4));   // 'o'
// s.charAt(5);  // StringIndexOutOfBoundsException

Nota: length() è il numero di unità di codice UTF-16, non sempre il numero di caratteri percepiti dall'utente. Per la maggior parte del testo ASCII e BMP coincidono, ma emoji e alcuni script non latini usano coppie surrogate e contano come 2.

Confrontare le stringhe

Usa .equals() per l'uguaglianza di contenuto, mai ==:

String a = new String("hi");
String b = new String("hi");

System.out.println(a == b);         // false
System.out.println(a.equals(b));    // true

equalsIgnoreCase ignora le maiuscole/minuscole:

"HELLO".equalsIgnoreCase("hello");  // true

Per l'ordinamento, usa compareTo. Confronta le stringhe lessicograficamente (per codice carattere) e restituisce un numero negativo quando la prima stringa viene prima della seconda, 0 quando sono uguali, e un numero positivo quando viene dopo:

"apple".compareTo("banana");        // negative (a < b)
"apple".compareTo("apple");         // 0  — equal
"banana".compareTo("apple");        // positive (b > a)

Poiché il confronto avviene per codice carattere, le lettere maiuscole (A–Z, codici 65–90) vengono prima delle minuscole (a–z, codici 97–122). Usa compareToIgnoreCase per un ordinamento senza distinzione tra maiuscole e minuscole.

Operazioni comuni

I metodi più utilizzati, con esempi:

String s = "  Hello, World!  ";

s.length();                  // 17
s.trim();                    // "Hello, World!" (whitespace removed)
s.strip();                   // "Hello, World!" (Unicode-aware, Java 11+)
s.toUpperCase();             // "  HELLO, WORLD!  "
s.toLowerCase();             // "  hello, world!  "
s.contains("World");         // true
s.startsWith("  Hello");     // true
s.endsWith("!  ");           // true
s.indexOf("World");          // 9
s.indexOf("xyz");            // -1
s.replace(",", ";");         // "  Hello; World!  "
s.substring(2, 7);           // "Hello"
s.split(", ");               // ["  Hello", "World!  "]
s.isEmpty();                 // false  — length() == 0?
s.isBlank();                 // false  — only whitespace? (Java 11+)

Per la documentazione completa, consulta Metodi String di Java.

Concatenazione

L'operatore + unisce le stringhe e converte altri tipi in stringa secondo necessità:

String name = "Ada";
int age = 36;
String msg = "Name: " + name + ", Age: " + age;
// "Name: Ada, Age: 36"

All'interno di un ciclo, preferisci StringBuilder:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++) {
    sb.append(i).append(",");
}
String result = sb.toString();

Text block — stringhe multiriga

Da Java 15, i text block consentono di scrivere stringhe multiriga senza caratteri di escape:

String json = """
        {
          "name": "Ada",
          "age": 36
        }
        """;

Il compilatore rimuove lo spazio bianco iniziale comune da ogni riga, così il rientro nel sorgente non si riversa nella stringa.

Formattazione

String.format costruisce una stringa con segnaposto in stile printf:

String s = String.format("Name: %s, Age: %d", "Ada", 36);

I segnaposto sono gli stessi di System.out.printf — consulta Output Java.

Una dimostrazione

Cosa c'è dopo

Metodi String di Java — un riferimento di ogni metodo che utilizzerai regolarmente.

Esercitati