Java String.split()-metoden

La oss snakke om Javas String.split- metode: hva den gjør og hvorfor den er nødvendig. Det er ikke vanskelig å gjette at den deler en Java-streng, men hvordan fungerer dette i praksis? La oss dykke dypt inn i driften av metoden og diskutere noen ikke-åpenbare detaljer. Samtidig vil vi lære hvor mange splittemetoder strengen faktisk har . La oss gå!

Beskrivelse og signatur for Javas String.split

I Java deler split- metoden en streng i understrenger ved å bruke et skilletegn definert ved hjelp av et regulært uttrykk. La oss presentere metodesignaturen og begynne vårt dykk:

String[] split(String regex)

To ting fremgår tydelig av signaturen:

1. Metoden returnerer en rekke strenger.
2. Metoden har en strenginndataparameter kalt regex .

La oss analysere hver av disse separat mens vi bryter ned beskrivelsen gitt ovenfor.

1. Metoden returnerer en rekke strenger.

   Erklæringen inneholder følgende ord: "I Java deler split- metoden en streng i understrenger." Metoden samler disse understrengene til en matrise som blir returverdien.

2. Metoden har en strenginndataparameter kalt regex .

   Igjen, husk beskrivelsen: "deler en streng i delstrenger ved å bruke et skilletegn definert ved hjelp av et regulært uttrykk." Regex - inndataparameteren er et regulært uttrykk som brukes på den opprinnelige strengen. Når tegnet eller kombinasjonen av tegn samsvarer, behandles de som et skilletegn.

Java er delt i praksis

La oss nå komme nærmere poenget. La oss forestille oss at vi har en rekke ord. For eksempel slik: Vi må dele strengen i ord. Vi ser at ordene i denne strengen er atskilt fra hverandre med mellomrom. I dette tilfellet er et mellomromstegn den perfekte kandidaten for skilletegn. Koden for å løse oppgaven vår vil se slik ut:

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

Utdata fra hovedmetoden vil være følgende linjer: La oss se noen flere eksempler på hvordan splittmetoden ville fungere: Legg merke til forskjellene mellom de to siste radene i tabellen ovenfor. I nest siste rad brukes komma som skilletegn. Som et resultat, når strengen er delt, har noen av ordene innledende mellomrom. På den siste raden brukte vi et komma og et mellomrom som skilletegn. Det er derfor det ikke var noen understrenger med ledende mellomrom i den resulterende matrisen. Dette er bare en subtil detalj som viser hvor viktig det er å velge riktig skilletegn nøye.

Ledende skilletegn

Dette er en annen viktig nyanse. Hvis den opprinnelige strengen begynner med skilletegnet, vil det første elementet i den resulterende matrisen være en tom streng. For eksempel vil det se slik ut: Originalstreng: " Jeg elsker Java" Skilletegn: " " Resulterende matrise: { "", "I", "love", "Java" } Men hvis den opprinnelige strengen slutter med et skilletegn heller enn å begynne med en, vil resultatet bli annerledes: Originalstreng: "Jeg elsker Java " Avgrensningstegn: " " 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 utgang vil være slik : Gjør igjen oppmerksomheten mot det faktum at når det første tegnet i den opprinnelige strengen er et skilletegn, så er resultatet at det første elementet i matrisen vil være en tom streng.

Overbelastet søsken

String - klassen har en annen splittmetode med følgende signatur:

String[] split(String regex, int limit)

Denne metoden har en ekstra grenseparameter : den bestemmer hvor mange ganger regex- mønsteret skal brukes på den opprinnelige strengen. Se forklaringene nedenfor:

grense > 0

Mønsteret påføres grense -1 ganger. I tillegg vil lengden på den returnerte matrisen ikke overskride verdien til grenseparameteren . Det siste elementet i matrisen vil være den delen av strengen som følger det siste stedet der skilletegnet ble funnet. 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));
    }
}

grense < 0

Det regulære skilletegnet brukes på strengen så mange ganger som mulig. Den resulterende matrisen kan ha hvilken som helst lengde. 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));
    }
}

grense = 0

Som i tilfellet der grense < 0, brukes skilletegnsmønsteret på strengen så mange ganger som mulig. Den endelige matrisen kan ha hvilken som helst lengde. Hvis de siste elementene er tomme strenger, blir de forkastet fra den endelige matrisen. 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 ser på implementeringen av en-parameterversjonen av split- metoden, kan vi se at det er som dets overbelastede søsken, men med det andre argumentet satt til null:

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

Ulike eksempler

I praksis i den virkelige verden hender det noen ganger at vi har strenger som er generert i henhold til visse regler. En slik streng kan komme inn i programmet vårt fra hvor som helst:

• fra en tredjepartstjeneste;
• fra en forespørsel sendt til vår server;
• fra en konfigurasjonsfil;
• og så videre.

I disse situasjonene kjenner programmereren vanligvis "spillereglene". La oss si at en programmerer vet at han eller hun har å gjøre med brukerinformasjon lagret i henhold til dette mønsteret: La oss ta noen spesifikke verdier som eksempel: Anta at programmererens oppgave er å skrive en metode som sender en e-post til brukeren. Programmereren har tilgang til brukerdata, som er registrert i formatet gitt ovenfor. Deloppgaven som vi nå skal fortsette å analysere er hvordan man kan isolere e-postadressen fra resten av brukerdataene. Dette er et tilfelle der splittmetoden kan være nyttig. Tross alt, hvis vi ser på brukerdatamalen, innser vi at å trekke ut brukerens e-postadresse fra resten er enkelt som å kalle split- metoden for å dele strengen. Da vil e-postadressen være i det siste elementet i den resulterende matrisen. Her er et eksempel på en metode som tar en streng som inneholder brukerdata og returnerer brukerens e-postadresse. For enkelhets skyld, la oss si at datastrengen alltid er i formatet 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]
    }
}

Legg merke til skilletegnet: "\\|" . I regulære uttrykk, "|" er et spesialtegn med spesiell betydning, så hvis vi vil bruke det som et vanlig tegn (dvs. det vi ønsker å finne i den opprinnelige strengen), så må vi unnslippe tegnet med to skråstreker. Tenk på et annet eksempel. La oss si at vi har ordreinformasjon som er strukturert slik: Eller vi kan til og med ta i bruk noen spesifikke verdier: Vår oppgave er å beregne totalkostnaden for bestillingen. Her må vi bruke splittmetoden flere ganger. Det første trinnet er å dele strengen ved å bruke ";" som skilletegnet for å dele det opp i komponentene. Deretter vil hver resulterende delstreng inneholde informasjon om et eget produkt, som vi kan behandle senere. Deretter, for hvert produkt, vil vi dele opp den tilsvarende informasjonen ved å bruke "," symbolet. Vi tar et element med en spesifikk indeks (den der produktprisen er lagret) fra den resulterende strengmatrisen, konverterer den til numerisk form og teller opp den totale kostnaden for bestillingen. La oss skrive en metode som vil gjøre alle disse beregningene:

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 finne ut hvordan denne metoden fungerer på egen hånd. Basert på disse eksemplene kan vi si at split- metoden brukes når vi har noen data formatert som en streng, og vi må trekke ut viss mer spesifikk informasjon fra den.

Sammendrag

Vi undersøkte splittmetoden til String -klassen. Det er akkurat det du trenger når du skal dele en streng i dens komponentdeler ved hjelp av en spesiell skilletegn. Metoden returnerer en rekke strenger (delstrengene som utgjør den opprinnelige strengen). Den aksepterer et regulært uttrykk hvis samsvar representerer skilletegn(ene). Vi undersøkte ulike finesser av denne metoden:

• en ledende skilletegn;
• dens overbelastede søsken med to parametere.

Vi prøvde også å modellere noen virkelige situasjoner der vi brukte splittmetoden for å løse hypotetiske, men ganske realistiske, problemer.