Modificare una Stringa in Java

Poiché gli oggetti String sono immutabili, ogni volta che vogliamo modificare una String, dobbiamo copiarla in un StringBuffer o StringBuilder, oppure usare un metodo String che costruisce una nuova copia della stringa con le nostre modifiche complete.

In questa lezione ci concentriamo sui metodi messi a disposizione dalla classe String per modificare le stringhe.

Estrarre una Sotto-stringa

È possibile estrarre una sotto-stringa utilizzando substring().

Ha due forme. La prima è:

String substring(int indiceInizio)

Qui, indiceInizio specifica l'indice al quale inizierà la sotto-stringa. Questa forma restituisce una copia della sotto-stringa che inizia a indiceInizio e va fino alla fine della stringa chiamante.

La seconda forma di substring() consente di specificare sia l'indice di inizio che quello di fine della sotto-stringa:

String substring(int indiceInizio, int indiceFine)

Qui, indiceInizio specifica l'indice di inizio, e indiceFine specifica il punto di arresto. La stringa restituita contiene tutti i caratteri dall'indice di inizio, fino a, ma non incluso, l'indice di fine.

Il seguente programma utilizza substring() per sostituire tutte le istanze di una sotto-stringa con un'altra all'interno di una stringa:

// Sostituzione di sottostringa.
class SostituzioneStringa {

    public static void main(String[] args) {
        String originale = "Questo è un test. Questo, anche, è un test.";
        String ricerca = "è";
        String sostituzione = "era";
        String risultato = "";

        int i;

        do {
            // sostituisce tutte le sottostringhe corrispondenti
            System.out.println(originale);

            i = originale.indexOf(ricerca);
            if (i != -1) {
                risultato = originale.substring(0, i);
                risultato = risultato + sostituzione;
                risultato = risultato + originale.substring(i + ricerca.length());
                originale = risultato;
            }

        } while (i != -1);
    }

}

L'output di questo programma è mostrato qui:

Questo è un test. Questo, anche, è un test.
Questo era un test. Questo, anche, è un test.
Questo era un test. Questo, anche, era un test.

Concatenare Stringhe

Oltre ad usare l'operatore + per concatenare due stringhe, Java fornisce anche il metodo concat(). Questo metodo ha la seguente forma:

String concat(String str)

Questo metodo crea un nuovo oggetto che contiene la stringa invocante con il contenuto di str aggiunto alla fine. concat() esegue la stessa funzione di +. Ad esempio,

String s1 = "uno";
String s2 = s1.concat("due");

inserisce la stringa "unodue" in s2. Genera lo stesso risultato della seguente sequenza:

String s1 = "uno";
String s2 = s1 + "due";

Sostituire Caratteri e Sotto-stringhe

Il metodo replace() ha due forme.

La prima sostituisce tutte le occorrenze di un carattere nella stringa chiamante con un altro carattere. Ha la seguente forma generale:

String replace(char originale, char sostituzione)

Qui, originale specifica il carattere da sostituire con il carattere specificato da sostituzione. La stringa risultante viene restituita. Ad esempio,

String s = "Ciao".replace('i', 'w');

mette la stringa "Cwao" in s.

La seconda forma di replace() sostituisce una sequenza di caratteri con un'altra. Ha questa forma generale:

String replace(CharSequence originale, CharSequence sostituzione)

Rimuovere gli Spazi Bianchi

Il metodo trim() restituisce una copia della stringa invocante dalla quale sono stati rimossi tutti gli spazi iniziali e finali.

Per quanto riguarda questo metodo, gli spazi consistono di quei caratteri corrispondenti a valori ASCII con un valore di 32 o inferiore. Il metodo trim() ha questa forma generale:

String trim()

Ecco un esempio:

String s = " Ciao Mondo ".trim();

Questo mette la stringa "Ciao Mondo" in s.

Il metodo trim() è molto utile quando si elaborano comandi dell'utente. Ad esempio, il seguente programma chiede all'utente il nome di uno stato e poi visualizza la capitale di quello stato. Usa trim() per rimuovere eventuali spazi iniziali o finali che potrebbero essere stati inseriti inavvertitamente dall'utente.

// Usare trim() per elaborare comandi.
import java.io.*;

class UsaTrim {

    public static void main(String[] args)
            throws IOException {

        // Crea un BufferedReader usando System.in
        BufferedReader br =
            new BufferedReader(
                new InputStreamReader(System.in, System.console().charset()));
        String str;
        System.out.println("Inserisci 'stop' per uscire.");
        System.out.println("Inserisci Stato: ");

        do {
            // Legge una riga di input dall'utente
            str = br.readLine();

            // Rimuove gli spazi iniziali e finali
            // dalla stringa inserita
            str = str.trim();

            if (str.equals("Italia"))
                System.out.println("La capitale è Roma.");
            else if (str.equals("Francia"))
                System.out.println("La capitale è Parigi.");
            else if (str.equals("Germania"))
                System.out.println("La capitale è Berlino.");
            else if (str.equals("Spagna"))
                System.out.println("La capitale è Madrid.");
            else
                System.out.println("Nessuna corrispondenza trovata.");
        } while (!str.equals("stop"));
    }

}

Un possibile output di questo programma è:

Inserisci 'stop' per uscire.
Inserisci Stato: 
Francia
La capitale è Parigi.
Germania
La capitale è Berlino.
Italia
La capitale è Roma.
stop
Nessuna corrispondenza trovata.

A partire da JDK 11, Java fornisce anche i metodi strip(), stripLeading() e stripTrailing().

Il metodo strip() rimuove tutti i caratteri di spazio bianco (come definiti da Java) dall'inizio e dalla fine della stringa invocante e restituisce il risultato. Tali caratteri di spazio bianco includono, tra gli altri, spazi, tabulazioni, ritorni a capo e avanzamenti di riga.

I metodi stripLeading() e stripTrailing() cancellano i caratteri di spazio bianco rispettivamente dall'inizio o dalla fine della stringa invocante e restituiscono il risultato. JDK 15 ha aggiunto i metodi stripIndent(), che rimuove gli spazi bianchi estranei mantenendo l'indentazione significativa, e translateEscapes(), che sostituisce le sequenze di escape con i loro equivalenti caratteri.