Metodo Java String.split()

Parliamo del metodo String.split di Java : cosa fa e perché è necessario. Non è difficile indovinare che divide una stringa Java, ma come funziona in pratica? Approfondiamo il funzionamento del metodo e discutiamo alcuni dettagli non ovvi. Allo stesso tempo, impareremo quanti metodi split ha effettivamente la stringa . Andiamo!

Descrizione e firma per String.split di Java

In Java, il metodo split suddivide una stringa in sottostringhe utilizzando un delimitatore definito utilizzando un'espressione regolare. Presentiamo la firma del metodo e iniziamo la nostra immersione:

String[] split(String regex)

Due cose sono chiare dalla firma:

1. Il metodo restituisce un array di stringhe.
2. Il metodo ha un parametro di input di stringa chiamato regex .

Analizziamo ciascuno di questi separatamente analizzando la descrizione fornita sopra.

1. Il metodo restituisce un array di stringhe.

   La dichiarazione contiene le seguenti parole: "In Java, il metodo split suddivide una stringa in sottostringhe". Il metodo raccoglie queste sottostringhe in un array che diventa il valore restituito.

2. Il metodo ha un parametro di input di stringa chiamato regex .

   Ancora una volta, ricorda la descrizione: "divide una stringa in sottostringhe usando un delimitatore definito usando un'espressione regolare". Il parametro di input regex è un'espressione regolare che viene applicata alla stringa originale. Quando il carattere o la combinazione di caratteri corrispondono, vengono trattati come un delimitatore.

La divisione di Java in pratica

Ora avviciniamoci al punto. Immaginiamo di avere una stringa di parole. Ad esempio, in questo modo: Dobbiamo dividere la stringa in parole. Vediamo che le parole in questa stringa sono separate l'una dall'altra da spazi. In questo caso, un carattere spazio è il candidato perfetto per il nostro delimitatore. Il codice per risolvere il nostro compito sarebbe simile a questo:

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: Vediamo alcuni altri esempi di come funzionerebbe il metodo split : Notare le differenze tra le ultime due righe nella tabella sopra. Nella penultima riga, viene utilizzata una virgola come delimitatore. Di conseguenza, quando la stringa viene divisa, alcune parole hanno spazi iniziali. Nell'ultima riga, abbiamo usato una virgola e uno spazio come delimitatore. Ecco perché non c'erano sottostringhe con spazi iniziali nell'array risultante. Questo è solo un sottile dettaglio che dimostra quanto sia importante scegliere con cura il giusto delimitatore.

Delimitatore principale

Questa è un'altra sfumatura importante. Se la stringa originale inizia con il delimitatore, il primo elemento dell'array risultante sarà una stringa vuota. Ad esempio, sarebbe simile a questo: Stringa originale: " I love Java" Delimitatore: " " Array risultante: { "", "I", "love", "Java" } Ma se la stringa originale termina con un delimitatore piuttosto piuttosto che iniziare con uno, il risultato sarà diverso: Stringa originale: "I love Java " Delimitatore: " " Array risultante: { "I", "love", "Java"

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ì: Rivolgi nuovamente la tua attenzione al fatto che quando il primo carattere nella stringa originale è un carattere delimitatore, il risultato è che il primo elemento nell'array sarà una stringa vuota.

Fratello sovraccarico

La classe String ha un altro metodo split con la seguente firma:

String[] split(String regex, int limit)

Questo metodo ha un parametro limite aggiuntivo : determina quante volte il modello regex verrà applicato alla stringa originale. Vedere le spiegazioni di seguito:

limite > 0

Il modello viene applicato limite -1 volte. Inoltre, la lunghezza dell'array restituito non supererà il valore del parametro limit . L'ultimo elemento dell'array sarà la parte della stringa che segue l'ultimo punto in cui è stato trovato il delimitatore. 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

L'espressione regolare delimitatore viene applicata alla stringa il maggior numero di volte possibile. L'array risultante può avere qualsiasi lunghezza. Esempio:

public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        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, ]

        Please note that the last element of the array is
        an empty string. This is caused by the whitespace
        at the end of the original string.
        */
    }

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

limite = 0

Come nel caso in cui limit < 0, il pattern delimitatore viene applicato alla stringa il maggior numero di volte possibile. L'array finale può avere qualsiasi lunghezza. Se gli ultimi elementi sono stringhe vuote, vengono scartati dall'array finale. Esempio:

public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        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 diamo un'occhiata all'implementazione della versione a un parametro del metodo split , possiamo vedere che è come il suo fratello sovraccarico, ma con il secondo argomento impostato su zero:

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

Vari esempi

Nella pratica del mondo reale, a volte capita di avere stringhe generate secondo determinate regole. Tale stringa potrebbe entrare nel nostro programma da qualsiasi luogo:

• da un servizio di terze parti;
• da una richiesta inviata al nostro server;
• da un file di configurazione;
• e così via.

In queste situazioni, il programmatore di solito conosce le "regole del gioco". Supponiamo che un programmatore sappia di avere a che fare con le informazioni dell'utente memorizzate secondo questo schema: Prendiamo alcuni valori specifici come esempio: Supponiamo che il compito del programmatore sia quello di scrivere un metodo che invii un'e-mail all'utente. Il programmatore ha accesso ai dati dell'utente, che vengono registrati nel formato sopra indicato. La sottoattività che ora continueremo ad analizzare è come isolare l'indirizzo e-mail dal resto dei dati dell'utente. Questo è un caso in cui il metodo split può essere utile. Dopotutto, se guardiamo al modello di dati dell'utente, ci rendiamo conto che estrarre l'indirizzo email dell'utente dal resto è semplice come chiamare il metodo split per dividere la stringa. Quindi l'indirizzo email sarà nell'ultimo elemento dell'array risultante. Ecco un esempio di un metodo che accetta una stringa contenente i dati dell'utente e restituisce l'indirizzo email dell'utente. Per semplicità, diciamo che la stringa di dati è sempre nel formato che vogliamo:

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]
    }
}

Notare il delimitatore: "\\|" . Nelle espressioni regolari, "|" è un carattere speciale con un significato speciale, quindi se vogliamo usarlo come un carattere ordinario (cioè quello che vogliamo trovare nella stringa originale), allora dobbiamo eseguire l'escape del carattere con due barre rovesciate. Considera un altro esempio. Supponiamo di avere informazioni sull'ordine strutturate in questo modo: Oppure possiamo anche adottare alcuni valori specifici: Il nostro compito è calcolare il costo totale dell'ordine. Qui dovremo applicare più volte il metodo split . Il primo passo è dividere la stringa usando ";" come delimitatore per scomporlo nelle sue parti componenti. Quindi ogni sottostringa risultante conterrà informazioni su un prodotto separato, che possiamo elaborare in seguito. Quindi, per ogni prodotto, suddivideremo le informazioni corrispondenti utilizzando il simbolo ",". Prenderemo un elemento con un indice specifico (quello in cui è memorizzato il prezzo del prodotto) dall'array di stringhe risultante, lo convertiremo in forma numerica e calcoleremo il costo totale dell'ordine. Scriviamo un metodo che farà tutti questi calcoli:

public class Main {
    public static void main(String[] args) {
        String orderInfo = "1,cucumbers,2.39;2,tomatoes,1.89;3,bacon,4.99";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 9.27
    }

    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;
    }
}

Vedi se riesci a capire come funziona questo metodo da solo. Sulla base di questi esempi, possiamo dire che il metodo split viene utilizzato quando abbiamo alcuni dati formattati come stringa e dobbiamo estrarre da esso alcune informazioni più specifiche.

Riepilogo

Abbiamo esaminato il metodo split della classe String . È proprio ciò di cui hai bisogno quando devi dividere una stringa nelle sue parti componenti con l'aiuto di un delimitatore speciale. Il metodo restituisce un array di stringhe (le sottostringhe che compongono la stringa originale). Accetta un'espressione regolare le cui corrispondenze rappresentano i caratteri delimitatori. Abbiamo esaminato varie sottigliezze di questo metodo:

• un delimitatore iniziale;
• il suo fratello sovraccarico con due parametri.

Abbiamo anche provato a modellare alcune situazioni di vita reale in cui abbiamo utilizzato il metodo split per risolvere problemi ipotetici, ma abbastanza realistici.