Java String.split() metode

Lad os tale om Javas String.split- metode: hvad den gør, og hvorfor den er nødvendig. Det er ikke svært at gætte, at den deler en Java-streng, men hvordan fungerer det i praksis? Lad os dykke dybt ned i metodens funktion og diskutere nogle ikke-indlysende detaljer. Samtidig lærer vi, hvor mange splitmetoder Stringen faktisk har . Lad os gå!

Beskrivelse og signatur for Javas String.split

I Java opdeler splitmetoden en streng i understrenge ved hjælp af et skilletegn defineret ved hjælp af et regulært udtryk. Lad os præsentere metodesignaturen og begynde vores dyk:

String[] split(String regex)

To ting fremgår tydeligt af underskriften:

1. Metoden returnerer en række strenge.
2. Metoden har en strenginputparameter kaldet regex .

Lad os analysere hver af disse separat, mens vi nedbryder beskrivelsen givet ovenfor.

1. Metoden returnerer en række strenge.

   Erklæringen indeholder følgende ord: "I Java opdeler splitmetoden en streng i understrenge." Metoden samler disse understrenge i et array, der bliver returværdien.

2. Metoden har en strenginputparameter kaldet regex .

   Husk igen beskrivelsen: "opdeler en streng i understrenge ved hjælp af et skilletegn defineret ved hjælp af et regulært udtryk." Regex - inputparameteren er et regulært udtryk, der anvendes på den originale streng. Når tegnet eller kombinationen af ​​tegn matcher, behandles de som en afgrænsning.

Java er splittet i praksis

Lad os nu komme tættere på sagen. Lad os forestille os, at vi har en række ord. For eksempel sådan her: Vi skal dele strengen op i ord. Vi ser, at ordene i denne streng er adskilt fra hinanden med mellemrum. I dette tilfælde er et mellemrumstegn den perfekte kandidat til vores afgrænsning. Koden til at løse vores opgave ville se sådan ud:

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

Outputtet af hovedmetoden vil være følgende linjer: Lad os se et par flere eksempler på, hvordan opdelingsmetoden ville fungere: Bemærk forskellene mellem de sidste to rækker i tabellen ovenfor. I den næstsidste række bruges et komma som afgrænsning. Som et resultat, når strengen er delt, har nogle af ordene indledende mellemrum. I sidste række brugte vi et komma og et mellemrum som vores afgrænsning. Det er derfor, der ikke var nogen understrenge med førende mellemrum i det resulterende array. Dette er blot en subtil detalje, der viser, hvor vigtigt det er at omhyggeligt vælge den rigtige afgrænsning.

Førende afgrænsning

Dette er en anden vigtig nuance. Hvis den oprindelige streng begynder med afgrænsningstegnet, vil det første element i det resulterende array være en tom streng. For eksempel ville det se sådan ud: Original streng: " Jeg elsker Java" Afgrænsningstegn: " " Resulterende array: { "", "I", "love", "Java" } Men hvis den oprindelige streng slutter med et skilletegn snarere end at begynde med én, så bliver resultatet anderledes: Original streng: "I love Java " Delimiter: " " Resulterende array: { "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));
    }
}

Hovedmetodens output vil være sådan : Drej igen din opmærksomhed på det faktum, at når det første tegn i den originale streng er et skilletegn, så er resultatet, at det første element i arrayet vil være en tom streng.

Overbelastet søskende

String - klassen har en anden splitmetode med følgende signatur:

String[] split(String regex, int limit)

Denne metode har en ekstra grænseparameter : den bestemmer, hvor mange gange regex- mønsteret vil blive anvendt på den originale streng. Se forklaringerne nedenfor:

grænse > 0

Mønsteret påføres grænse -1 gange. Hvad mere er, vil længden af ​​det returnerede array ikke overstige værdien af ​​grænseparameteren . Det sidste element i arrayet vil være den del af strengen, der følger efter det sidste sted, hvor afgrænseren blev fundet. Eksempel:

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

grænse < 0

Det regulære afgrænsningsudtryk anvendes på strengen så mange gange som muligt. Det resulterende array kan have en hvilken som helst længde. Eksempel:

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

grænse = 0

Som i tilfældet, hvor grænse < 0, anvendes afgrænsningsmønsteret på strengen så mange gange som muligt. Det endelige array kan have en hvilken som helst længde. Hvis de sidste elementer er tomme strenge, kasseres de fra det endelige array. Eksempel:

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

Hvis vi kigger på implementeringen af ​​en-parameter-versionen af ​​split -metoden, så kan vi se, at det er som sin overbelastede søskende, men med det andet argument sat til nul:

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

Forskellige eksempler

I praksis i den virkelige verden sker det nogle gange, at vi har strenge, der er genereret efter bestemte regler. Sådan en streng kan komme ind i vores program hvor som helst fra:

• fra en tredjepartstjeneste;
• fra en anmodning sendt til vores server;
• fra en konfigurationsfil;
• og så videre.

I disse situationer kender programmøren normalt "spillets regler". Lad os sige, at en programmør ved, at han eller hun beskæftiger sig med brugeroplysninger, der er gemt i henhold til dette mønster: Lad os tage nogle specifikke værdier som et eksempel: Antag, at programmørens opgave er at skrive en metode, der sender en e-mail til brugeren. Programmøren har adgang til brugerdata, som er optaget i det ovenfor angivne format. Den delopgave, som vi nu vil fortsætte med at analysere, er, hvordan man isolerer e-mailadressen fra resten af ​​brugerdataene. Dette er et tilfælde, hvor splitmetoden kan være nyttig. Når alt kommer til alt, hvis vi ser på brugerdataskabelonen, indser vi, at det at udtrække brugerens e-mailadresse fra resten er ganske enkelt som at kalde splitmetoden for at opdele strengen. Så vil e-mailadressen være i det sidste element i det resulterende array. Her er et eksempel på en metode, der tager en streng, der indeholder brugerdata og returnerer brugerens e-mailadresse. Lad os for nemheds skyld sige, at datastrengen altid er i det format, vi ønsker:

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

Bemærk afgrænsningstegnet: "\\|" . I regulære udtryk "|" er et specialtegn med særlig betydning, så hvis vi vil bruge det som et almindeligt tegn (dvs. det vi vil finde i den originale streng), så skal vi undslippe tegnet med to omvendte skråstreg. Overvej et andet eksempel. Lad os sige, at vi har ordreinformation, der er struktureret sådan: Eller vi kan endda vedtage nogle specifikke værdier: Vores opgave er at beregne den samlede pris for ordren. Her bliver vi nødt til at anvende splitmetoden flere gange. Det første trin er at opdele strengen ved hjælp af ";" som afgrænsning for at opdele det i dets bestanddele. Så vil hver resulterende understreng indeholde information om et separat produkt, som vi kan behandle senere. Derefter vil vi for hvert produkt opdele den tilsvarende information ved at bruge "," symbolet. Vi vil tage et element med et specifikt indeks (det, hvor produktprisen er gemt) fra den resulterende strengmatrix, konvertere den til numerisk form og opgøre den samlede pris for ordren. Lad os skrive en metode, der vil udføre alle disse beregninger:

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

Se, om du kan finde ud af, hvordan denne metode fungerer på egen hånd. Baseret på disse eksempler kan vi sige, at splitmetoden bruges , når vi har nogle data formateret som en streng, og vi skal udtrække visse mere specifikke oplysninger fra dem.

Resumé

Vi undersøgte splitmetoden for String- klassen. Det er lige, hvad du har brug for, når du skal opdele en streng i dens bestanddele ved hjælp af en speciel afgrænsning. Metoden returnerer et array af strenge (de understrenge, der udgør den originale streng). Det accepterer et regulært udtryk, hvis overensstemmelser repræsenterer skilletegn(erne). Vi undersøgte forskellige finesser af denne metode:

• en ledende afgrænsning;
• sin overbelastede søskende med to parametre.

Vi forsøgte også at modellere nogle virkelige situationer, hvor vi brugte splitmetoden til at løse hypotetiske, men ret realistiske, problemer.