Metodo Split in Java: divide una stringa in parti

Parliamo del metodo String split : cosa fa e perché è necessario. È facile intuire che divide la corda, ma come funziona in pratica? Diamo uno sguardo più da vicino a come funziona il metodo e discutiamo alcuni dettagli non ovvi, e allo stesso tempo scopriamo quanti metodi split ci sono effettivamente nella classe String . Andiamo!

Definizione e firma per Java String.split

Il metodo split in Java divide una stringa in sottostringhe utilizzando un delimitatore specificato utilizzando un'espressione regolare. Diamo la firma del metodo e iniziamo la nostra immersione:

String[] split(String regex)

Dalla firma risultano chiare due cose:

1. Il metodo restituisce un array di stringhe.
2. Il metodo accetta una stringa regex come parametro.

Diamo un'occhiata a ciascuna cosa separatamente nei termini della definizione data sopra.

1. Il metodo restituisce un array di stringhe.

   La definizione contiene le seguenti parole: "Il metodo split in Java divide una stringa in sottostringhe". Queste sottostringhe vengono raccolte dal metodo in un array e ne rappresentano il valore restituito.

2. Il metodo accetta una stringa regex come parametro.

   Ancora una volta, ricorda la definizione: "divide una stringa in sottostringhe utilizzando un delimitatore specificato utilizzando un'espressione regolare". Il parametro regex accettato è un modello di espressione regolare che viene applicato alla stringa di origine e corrisponde al carattere delimitatore (o combinazione di caratteri) nella stringa di origine.

Diviso in pratica

Ora passiamo agli affari. Immaginiamo di avere una stringa con parole. Ad esempio, in questo modo: Dobbiamo spezzare la stringa in parole. Vediamo che in questa riga le parole sono separate l'una dall'altra da spazi. In questo caso lo spazio è un candidato ideale per il ruolo di separatore. Ecco come appare il codice per risolvere questo problema:

public class Main {
    public static void main(String[] args) {
        String str = "I love Java";
        String[] words = str.split(" ");
        for (String word : words) {
            System.out.println(word);
        }
    }
}

L'output del metodo main saranno le seguenti righe: Diamo un'occhiata ad alcuni altri esempi di come funzionerebbe il metodo di divisione : Notare le differenze tra le ultime due righe nella tabella sopra. Nella penultima riga, il delimitatore è una virgola, quindi la riga è divisa in modo tale che alcune parole abbiano spazi iniziali. Nell'ultima riga abbiamo utilizzato una virgola e uno spazio come delimitatore. Pertanto, la matrice risultante non conteneva righe con spazi iniziali. Questo è solo un piccolo dettaglio che dimostra quanto sia importante scegliere con attenzione il corretto separatore.

Delimitatore principale

C'è un'altra sfumatura importante. Se la stringa di origine inizia con un delimitatore, il primo elemento dell'array risultante sarà la stringa vuota. In un esempio, sarebbe simile a questo: Stringa di origine: "I love Java" Delimitatore: " " Array risultante: { "" , "I" , "love" , "Java" } Ma se la stringa di origine termina con un delimitatore e non inizia, il risultato sarà diverso: Stringa sorgente: "I love Java" Separatore: " " Array risultante: { "I" , "love" , "Java" } Esaminiamo nel codice le variazioni del metodo split con un carattere separatore alla fine e/o all'inizio della stringa sorgente:

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" "));
        print(" I love Java".split(" "));
        print("I love Java ".split(" "));
        print(" I love Java ".split(" "));
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

L'output del metodo main sarà così: Si noti ancora che quando il primo carattere nella stringa sorgente è un carattere delimitatore, l'array risultante avrà la stringa vuota come primo elemento.

Un tipo sovraccarico

La classe String ha un altro metodo split con questa firma:

String[] split(String regex, int limit)

Questo metodo ha un parametro limite aggiuntivo : determina il numero di volte in cui il modello regex verrà applicato alla stringa sorgente. Di seguito sono riportate le spiegazioni:

limite > 0

viene applicato il limite -1 volte . In questo caso, la lunghezza dell'array non supererà il valore limite . L'ultimo elemento dell'array sarà la parte della stringa successiva all'ultimo delimitatore trovato. Esempio:

public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" ", 1));
        print("I love Java".split(" ", 2));
        /*
         Output:
         [I love Java]
         [I, love Java]
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

limite < 0

Il modello di ricerca del delimitatore viene applicato alla stringa il maggior numero di volte possibile. La lunghezza dell'array risultante può essere qualsiasi. Esempio:

public class Main {
    public static void main(String[] args) {
        // Notice the space at the end of the line
        print("I love Java ".split(" ", -1));
        print("I love Java ".split(" ", -2));
        print("I love Java ".split(" ", -12));
        /*
         Output:
        [I, love, Java, ]
        [I, love, Java, ]
        [I, love, Java, ]

        Note that the last element of the array is
        an empty string, resulting from the space
        at the end of the original string.
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

limite 0

Come con limit < 0, il modello di delimitazione viene applicato alla stringa il maggior numero di volte possibile. La matrice risultante può avere qualsiasi lunghezza. Se gli ultimi elementi sono uguali alla stringa vuota, verranno scartati nell'array finale. Esempio:

public class Main {
    public static void main(String[] args) {
        // Notice the space at the end of the line
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        /*
         Output:
        [I, love, Java]
        [I, love, Java]
        [I, love, Java]
        Note the absence of empty strings at the end of the arrays
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

Se osserviamo l'implementazione del metodo split con un argomento, vediamo che questo metodo chiama il fratello sovraccaricato con un secondo argomento pari a zero:

public String[] split(String regex) {
    return split(regex, 0);
}

Vari esempi

Nella pratica lavorativa, a volte capita che abbiamo una riga compilata secondo determinate regole. Questa linea può “entrare” nel nostro programma da qualsiasi luogo:

• da un servizio di terze parti;
• da una richiesta al nostro server;
• dal file di configurazione;
• eccetera.

Di solito in una situazione del genere il programmatore conosce le “regole del gioco”. Diciamo che il programmatore sa di avere informazioni sull'utente, che vengono memorizzate secondo questo schema: Ad esempio, prendiamo valori specifici: E ora il programmatore deve affrontare il compito: scrivere un metodo che invii un'e-mail all'utente. A sua disposizione ci sono le informazioni sull'utente, registrate nel formato sopra. Bene, l'attività secondaria che continueremo ad analizzare è isolare l'indirizzo email dalle informazioni generali sull'utente. Questo è un esempio in cui il metodo di divisione può essere utile. Dopotutto, se guardiamo il modello, capiamo che per estrarre l'indirizzo email dell'utente da tutte le informazioni, dobbiamo solo dividere la riga utilizzando il metodo split . Quindi l'indirizzo email sarà nell'ultimo elemento dell'array risultante. Diamo un esempio di tale metodo, che accetta una stringa contenente informazioni sull'utente e restituisce l'e-mail dell'utente. Per semplificare, supponiamo che questa stringa corrisponda sempre al formato di cui abbiamo bisogno:

public class Main {
    public static void main(String[] args) {
        String userInfo = "135|bender|bender@gmail.com";
        System.out.println(getUserEmail(userInfo));
        // Output: bender@gmail.com
    }

    static String getUserEmail(String userInfo) {
        String[] data = userInfo.split("\\|");
        return data[2]; // or data[data.length - 1]
    }
}

Nota il separatore: "\\|" . Poiché nelle espressioni regolari “|” - questo è un carattere speciale a cui è legata una certa logica; per usarlo come normale (quello che vogliamo trovare nella stringa sorgente), dobbiamo sfuggire a questo carattere usando due barre rovesciate. Diamo un'occhiata a un altro esempio. Supponiamo di avere informazioni su un ordine, che sono scritte approssimativamente in questo formato: Bene, oppure prendiamo valori specifici: Ci troviamo di fronte al compito di calcolare il costo totale dell'ordine. Qui dovremo utilizzare più volte il metodo split . Il primo passo è dividere la stringa tramite il simbolo ";" nelle sue parti componenti. Quindi in ciascuna di queste parti avremo informazioni su un singolo prodotto, che potremo elaborare in futuro. E poi, all'interno di ciascun prodotto, separeremo le informazioni utilizzando il simbolo "," e prenderemo dall'array risultante un elemento con un determinato indice (in cui è memorizzato il prezzo), lo convertiremo in una forma numerica e compileremo il costo finale dell'ordine. Scriviamo un metodo che calcolerà tutto questo:

public class Main {
    public static void main(String[] args) {
        String orderInfo = "1, cucumbers, 20.05; 2, tomatoes, 123.45; 3, hares, 0.50";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 144.0
    }

    static double getTotalOrderAmount(String orderInfo) {
        double totalAmount = 0d;
        final String[] items = orderInfo.split(";");

        for (String item : items) {
            final String[] itemInfo = item.split(",");
            totalAmount += Double.parseDouble(itemInfo[2]);
        }

        return totalAmount;
    }
}

Prova a capire da solo come funziona questo metodo. Sulla base di questi esempi possiamo dire che il metodo split viene utilizzato quando abbiamo delle informazioni sotto forma di stringa, da cui dobbiamo estrarre alcune informazioni più specifiche.

Risultati

Abbiamo esaminato il metodo split della classe String . È necessario dividere una stringa nelle sue parti componenti utilizzando un delimitatore speciale. Il metodo restituisce un array di stringhe (i componenti di una stringa). Accetta un'espressione regolare che trova i caratteri delimitatori. Abbiamo esaminato le varie sottigliezze di questo metodo:

• carattere delimitatore iniziale;
• fratello sovraccarico di due argomenti.

Abbiamo anche provato a simulare alcune situazioni di “vita reale” in cui abbiamo utilizzato il metodo split per risolvere problemi, seppur fittizi, ma abbastanza realistici.