Stringhe in Java: creare, concatenare e usare i metodi di String

Cos'è una stringa

Una String contiene una sequenza di caratteri: un testo come un nome, una frase o una riga letta da un file. Nella pagina precedente hai visto String tra i tipi riferimento; qui ci lavorerai davvero. Scrivi un letterale stringa tra virgolette doppie (gli apici singoli sono riservati a un singolo char):

public class Main {
    public static void main(String[] args) {
        String greeting = "Hello, world";
        String empty = "";
        String name = "Ada";

        System.out.println(greeting);
        System.out.println("Name has " + name.length() + " characters");
    }
}

name.length() restituisce il numero di caratteri: 3 per "Ada". È una chiamata a un metodo, quindi servono le parentesi.

Unire le stringhe

L'operatore + incolla le stringhe. Se uno dei due lati di + è una stringa, l'altro lato viene convertito automaticamente in testo, quindi puoi mescolare numeri e booleani senza lavoro in più:

public class Main {
    public static void main(String[] args) {
        String first = "Ada";
        String last = "Lovelace";

        String full = first + " " + last;
        System.out.println(full);

        int age = 36;
        System.out.println(full + " is " + age + " years old");
    }
}

Una trappola: poiché + lavora da sinistra a destra, "" + 1 + 2 produce "12" (stringa + int, poi stringa + int), mentre 1 + 2 + "" produce "3" (i due int si sommano prima, poi diventano testo). Nel dubbio, metti i calcoli tra parentesi.

Le stringhe sono immutabili

È la cosa più importante da capire sulle stringhe in Java: una String non cambia mai dopo essere stata creata. Ogni metodo che "modifica" una stringa in realtà restituisce una stringa completamente nuova e lascia intatta quella originale. Quindi, se dimentichi di salvare il valore restituito, non succede niente:

public class Main {
    public static void main(String[] args) {
        String s = "hello";

        s.toUpperCase();              // risultato buttato via: bug!
        System.out.println(s);        // ancora "hello"

        s = s.toUpperCase();          // salva la nuova stringa
        System.out.println(s);        // ora "HELLO"
    }
}

La prima chiamata calcola "HELLO" e lo scarta subito. Solo la seconda riga, che riassegna il risultato a s, ha un effetto visibile. Prima o poi capita a quasi tutti.

Confrontare le stringhe

Usa .equals() per confrontare il contenuto di due stringhe. Usare == è il classico errore dei principianti: == chiede "sono lo stesso oggetto in memoria?", non "contengono lo stesso testo?":

public class Main {
    public static void main(String[] args) {
        String a = "code";
        String b = new String("code");

        System.out.println(a == b);            // false - different objects
        System.out.println(a.equals(b));       // true  - same characters

        System.out.println("Hi".equalsIgnoreCase("hi"));  // true
    }
}

Qui a == b è false perché new String(...) crea per forza un oggetto separato. Confronta sempre i valori delle stringhe con .equals() (o con .equalsIgnoreCase() per ignorare le maiuscole). Un trucco utile per evitare un crash quando uno dei due lati potrebbe essere null è chiamare .equals sul letterale: "yes".equals(input) non lancia mai eccezioni, anche se input è null.

I metodi di String di tutti i giorni

Poiché le stringhe sono immutabili, ognuno di questi metodi restituisce una nuova stringa (o un valore) invece di modificare l'originale. Sono quelli che userai di continuo:

public class Main {
    public static void main(String[] args) {
        String s = "  Coddy Java  ";

        System.out.println(s.trim());              // "Coddy Java"
        System.out.println(s.trim().toUpperCase()); // "CODDY JAVA"
        System.out.println(s.contains("Java"));    // true
        System.out.println(s.indexOf("Java"));     // 8
        System.out.println("Coddy".charAt(0));     // 'C'
        System.out.println("a,b,c".split(",").length); // 3
        System.out.println("hello".replace("l", "L")); // "heLLo"
    }
}

Nota il concatenamento: s.trim().toUpperCase() funziona perché trim() restituisce una stringa, su cui poi chiami toUpperCase(). substring è un altro metodo fondamentale: riceve un indice iniziale (incluso) e un indice finale facoltativo (escluso):

public class Main {
    public static void main(String[] args) {
        String date = "2026-06-04";

        System.out.println(date.substring(0, 4));  // "2026"
        System.out.println(date.substring(5));     // "06-04"
    }
}

Gli indici partono da zero, quindi substring(0, 4) prende i caratteri da 0 a 3. Chiedere un indice oltre la fine lancia una StringIndexOutOfBoundsException, una delle eccezioni a runtime da cui puoi proteggerti. Nota anche che split(",") qui sopra ti restituisce un array, dove length è un campo senza parentesi, a differenza del metodo .length() di una stringa.

Costruire stringhe in un ciclo

Concatenare con + va bene per pochi pezzi, ma farlo dentro un ciclo lungo è lento: ogni + crea una nuova stringa e copia tutto. Quando componi un testo in un ciclo, usa StringBuilder, che modifica un buffer sul posto e produce la stringa finale una sola volta alla fine:

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        String result = sb.toString().trim();
        System.out.println(result);   // "1 2 3 4 5"
    }
}

append restituisce lo stesso builder, quindi le chiamate si possono concatenare. Alla fine chiama .toString() per ottenere una normale String. Per unioni occasionali resta su +; per accumulare molti pezzi, lo strumento giusto è StringBuilder.

Prossima pagina: formattare le stringhe

La concatenazione diventa disordinata quando ti servono colonne allineate, un numero fisso di decimali o numeri con padding. String.format e printf di Java usano un template con segnaposto % per gestire tutto questo in modo pulito: è l'argomento della prossima pagina.