1. Cos’è una stringa in Java

In Java, una stringa è una sequenza di caratteri, rappresentata dalla classe java.lang.String (vedi la documentazione ufficiale Oracle). Pertanto, le stringhe vengono usate ovunque: per messaggi all’utente, input da tastiera, file di testo, URL, ecc.

Alcuni modi comuni per creare una stringa:

String s1 = "Ciao";                    // letterale di stringa
String s2 = new String("Ciao");       // usa l'operatore new (sconsigliato di solito)
String vuota = "";                    // stringa vuota, lunghezza 0
String daChar = String.valueOf(123);   // converte un numero in stringa

Nella pratica quotidiana, in particolare, si usa quasi sempre la forma con i doppi apici ("testo").

2. Immutabilità della classe String

Di conseguenza, la classe String è immutabile. Significa che, una volta creata, una stringa non può essere modificata. Qualsiasi operazione che sembra “modificare” una stringa in realtà crea un nuovo oggetto String.

In questo modo, vediamo un esempio:

String s = "Ciao";
s = s.toUpperCase();   // crea una NUOVA stringa "CIAO" e la assegna a s

// s ora vale "CIAO". L'oggetto "Ciao" originale potrebbe essere rimosso dal GC.

Quindi, elenchiamo le conseguenze pratiche:

• Le stringhe sono thread-safe (possono essere condivise tra thread senza problemi di concorrenza).
• Inoltre, operazioni ripetute di concatenazione (es. in un ciclo) possono essere lente, perché creano tante nuove stringhe: in questi casi è meglio usare StringBuilder.
• Infine, puoi passare stringhe ai metodi senza paura che vengano modificate accidentalmente.

3. Metodi principali della classe String

Inoltre, la classe String offre molti metodi utili. Vediamo i più importanti con esempi.

3.1 length() delle Stringhe in Java

Infine, restituisce la lunghezza della stringa (numero di caratteri):

String s = "Java";
int len = s.length();  // len = 4

3.2 charAt(int index)

In particolare, restituisce il carattere all’indice specificato (partendo da 0):

String s = "Java";
char c = s.charAt(0);  // 'J'
char d = s.charAt(3);  // 'a'

3.3 substring()

Quindi, estrae una parte della stringa. beginIndex è incluso, endIndex è escluso:

String s = "Programmazione";
String sub1 = s.substring(0, 7);   // "Program"
String sub2 = s.substring(7);      // "mazione" (fino alla fine)

Attenzione: se gli indici sono fuori dal range 0..length()-1, viene lanciata StringIndexOutOfBoundsException.

3.4 indexOf() e lastIndexOf()

Di conseguenza, cercano la posizione di un carattere o di una sottostringa. Restituiscono l’indice trovato, oppure -1 se non c’è corrispondenza.

String s = "banana";
int i1 = s.indexOf('a');       // 1 (prima 'a')
int i2 = s.indexOf("na");     // 2
int i3 = s.lastIndexOf('a');  // 5 (ultima 'a')
int i4 = s.indexOf("xyz");    // -1 (non trovata)

3.5 equals() ed equalsIgnoreCase() per le Stringhe Java

In altri termini, confrontano il contenuto di due stringhe. equals è sensibile alle maiuscole/minuscole, equalsIgnoreCase no.

String a = "Java";
String b = "Java";
String c = "java";

boolean r1 = a.equals(b);             // true
boolean r2 = a.equals(c);             // false
boolean r3 = a.equalsIgnoreCase(c);   // true

3.6 startsWith() e endsWith()

Allo stesso modo, verificano se una stringa inizia o finisce con una certa sequenza di caratteri:

String s = "documento.pdf";
boolean b1 = s.startsWith("doc"); // true
boolean b2 = s.endsWith(".pdf");  // true
boolean b3 = s.endsWith(".txt");  // false

3.7 toUpperCase() e toLowerCase()

Per esempio, restituiscono una nuova stringa con tutti i caratteri maiuscoli o minuscoli:

String s = "Java";
String maiuscola = s.toUpperCase(); // "JAVA"
String minuscola = s.toLowerCase(); // "java"

3.8 trim() e strip()

Inoltre, rimuovono gli spazi bianchi all’inizio e/o alla fine della stringa. trim() è il metodo più comune, strip e varianti sono più moderni (Java 11+).

String s = "   ciao   ";
String t1 = s.trim();          // "ciao"
String t2 = s.strip();         // "ciao" (più completo di trim)
String t3 = s.stripLeading();  // "ciao   "
String t4 = s.stripTrailing(); // "   ciao"

3.9 replace() e replaceAll()

Pertanto, sostituiscono parti della stringa. replace lavora con caratteri o sottostringhe letterali; replaceAll usa espressioni regolari (regex).

String s = "1,2,3,4";
String t1 = s.replace(",", ";");      // "1;2;3;4" (tutte le virgole diventano punti e virgola)

String testo = "ciao 123 ciao 456";
String soloLettere = testo.replaceAll("[0-9]", ""); // "ciao  ciao " (rimuove le cifre)

In conclusione, se non ti servono le regex, preferisci replace: è più semplice e chiaro.

3.10 split() per le Stringhe in Java

In questa guida, dividiamo una stringa in un array di sottostringhe, usando un separatore (espressione regolare).

String s = "Mario;Rossi;35";
String[] parti = s.split(";");
// parti[0] = "Mario", parti[1] = "Rossi", parti[2] = "35"

Ad esempio, puoi anche specificare un limite massimo di parti:

String s = "a;b;c;d";
String[] dueParti = s.split(";", 2);
// ["a", "b;c;d"]

3.11 contains(), isEmpty(), isBlank()

Infine, vediamo metodi di utilità per controllare il contenuto:

String s = "  ";
boolean c1 = s.contains("a");   // false
boolean c2 = s.isEmpty();        // false (lunghezza 2: ci sono spazi)
boolean c3 = s.isBlank();        // true  (solo spazi/bianchi)

4. Confronto tra stringhe: == vs equals()

In Java, l’operatore == confronta i riferimenti (cioè se due variabili puntano allo stesso oggetto in memoria), mentre equals() confronta il contenuto della stringa.

String s1 = "Java";
String s2 = "Java";
String s3 = new String("Java");

System.out.println(s1 == s2);      // true? Di solito sì, perché i letterali sono internati
System.out.println(s1 == s3);      // false (oggetti diversi)
System.out.println(s1.equals(s3)); // true (stesso contenuto)

Di conseguenza, la regola pratica è: usa sempre equals (o equalsIgnoreCase) per confrontare stringhe, non ==, a meno che tu non abbia un motivo molto specifico per controllare il riferimento.

Inoltre, attenzione anche all’ordine: per evitare NullPointerException, scrivi così:

String input = null;

// EVITA: input.equals("ciao"); // lancia NullPointerException se input è null

// MEGLIO:
boolean ok = "ciao".equals(input);  // restituisce semplicemente false se input è null

5. Concatenazione di stringhe

Pertanto, ci sono diversi modi per unire stringhe in Java.

5.1 Concatenare stringhe con + e +=

In questo modo, il metodo più semplice e leggibile è ottimo per poche concatenazioni:

String nome = "Mario";
String saluto = "Ciao " + nome + "!";   // "Ciao Mario!"

String s = "a";
s += "b";     // s = "ab";
s += "c";     // s = "abc";

Tuttavia, per molte concatenazioni dentro un ciclo, è meglio usare StringBuilder per motivi di performance (vedi sezione successiva).

6. StringBuilder e StringBuffer

Di conseguenza, StringBuilder e StringBuffer sono classi pensate per costruire stringhe in modo efficiente, evitando di creare oggetti String intermedi ad ogni concatenazione.

6.1 StringBuilder per le stringhe in Java

Inoltre, StringBuilder è la scelta consigliata nella maggior parte dei casi. Non è thread-safe, ma è più veloce di StringBuffer. È ideale quando costruisci una stringa passo passo, magari in un ciclo.

StringBuilder sb = new StringBuilder();

for (int i = 1; i <= 5; i++) {
    sb.append("Numero: ");
    sb.append(i);
    sb.append("\n");
}

String risultato = sb.toString();
System.out.println(risultato);

/* Output:
Numero: 1
Numero: 2
Numero: 3
Numero: 4
Numero: 5
*/

In questo modo, elenchiamo i metodi principali di StringBuilder:

• append(...): aggiunge testo alla fine
• insert(pos, ...): inserisce testo in una certa posizione
• delete(start, end): rimuove una parte
• reverse(): inverte l’ordine dei caratteri
• toString(): converte il contenuto in una stringa immutabile String

6.2 StringBuffer per le Stringhe in Java

Invece, StringBuffer è simile a StringBuilder, ma è thread-safe: i suoi metodi sono sincronizzati, quindi può essere usato con più thread contemporaneamente senza conflitti. Questo però lo rende un po’ più lento.

Infine, in nuovo codice, di solito si preferisce StringBuilder, a meno che tu non abbia davvero bisogno di sicurezza tra thread sullo stesso oggetto.

StringBuffer sbuf = new StringBuffer("Inizio");
sbuf.append(" e fine");
String risultato = sbuf.toString();  // "Inizio e fine"

7. Esempi pratici con le stringhe in Java

7.1 Validare un indirizzo email con le stringhe in Java

Ad esempio, un controllo di base (non perfetto, ma utile per iniziare) può verificare che ci sia una @ e almeno un punto dopo:

public static boolean emailValida(String email) {
    if (email == null || email.isBlank()) {
        return false;
    }

    email = email.trim();

    int posChiocciola = email.indexOf('@');
    if (posChiocciola <= 0) {
        return false; // chiocciola mancante o come primo carattere
    }

    int posPunto = email.indexOf('.', posChiocciola);
    if (posPunto <= posChiocciola + 1) {
        return false; // nessun punto dopo la chiocciola
    }

    return true;
}

7.2 Suddividere una Stringa CSV in Java

In questo modo, supponiamo di avere una riga CSV (valori separati da virgole) e volerla trasformare in campi:

String riga = "Mario,Rossi,35,Roma";
String[] campi = riga.split(",");

String nome = campi[0];
String cognome = campi[1];
int eta = Integer.parseInt(campi[2]);
String citta = campi[3];

7.3 Normalizzare Stringhe Java in input

Pertanto, quando l’utente inserisce del testo, spesso vuoi ignorare maiuscole/minuscole e spazi extra:

Scanner scanner = new Scanner(System.in);
System.out.print("Vuoi continuare? (s/n): ");
String risposta = scanner.nextLine();

if (risposta != null) {
    risposta = risposta.trim().toLowerCase();

    if (risposta.equals("s") || risposta.equals("si") || risposta.equals("sì")) {
        System.out.println("Ok, continuo...");
    } else {
        System.out.println("Fine programma.");
    }
}

7.4 Costruire una Stringa Java in un ciclo

Ad esempio, vediamo un esempio con StringBuilder per creare una tabella di moltiplicazione:

public static String tabellina(int n) {
    StringBuilder sb = new StringBuilder();

    for (int i = 1; i <= 10; i++) {
        sb.append(n)
          .append(" x ")
          .append(i)
          .append(" = ")
          .append(n * i)
          .append("\n");
    }

    return sb.toString();
}

public static void main(String[] args) {
    System.out.println(tabellina(7));
}