Java String.split()-metoden

Låt oss prata om Javas String.split- metod: vad den gör och varför den behövs. Det är inte svårt att gissa att den delar en Java-sträng, men hur fungerar detta i praktiken? Låt oss dyka djupt in i hur metoden fungerar och diskutera några icke-uppenbara detaljer. Samtidigt kommer vi att lära oss hur många splitmetoder strängen faktiskt har . Nu går vi!

Beskrivning och signatur för Javas String.split

I Java delar splitmetoden en sträng i delsträngar med hjälp av en avgränsare som definieras med ett reguljärt uttryck . Låt oss presentera metodsignaturen och börja vårt dyk:

String[] split(String regex)

Två saker framgår av signaturen:

1. Metoden returnerar en array av strängar.
2. Metoden har en stränginmatningsparameter som kallas regex .

Låt oss analysera var och en av dessa separat när vi bryter ner beskrivningen ovan.

1. Metoden returnerar en array av strängar.

   Deklarationen innehåller följande ord: "I Java delar split- metoden en sträng i delsträngar." Metoden samlar dessa delsträngar till en array som blir returvärdet.

2. Metoden har en stränginmatningsparameter som kallas regex .

   Återigen, kom ihåg beskrivningen: "delar en sträng i delsträngar med hjälp av en avgränsare definierad med ett reguljärt uttryck." Indataparametern för regex är ett reguljärt uttryck som tillämpas på den ursprungliga strängen. När tecknet eller kombinationen av tecken matchar, behandlas de som en avgränsare.

Java har splittrats i praktiken

Låt oss nu komma närmare saken. Låt oss föreställa oss att vi har en rad ord. Till exempel, så här: Vi måste dela upp strängen i ord. Vi ser att orden i denna sträng är separerade från varandra med mellanslag. I det här fallet är ett mellanslagstecken den perfekta kandidaten för vår avgränsare. Koden för att lösa vår uppgift skulle se ut så här:

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 från huvudmetoden kommer att vara följande rader: Låt oss se några fler exempel på hur uppdelningsmetoden skulle fungera: Lägg märke till skillnaderna mellan de två sista raderna i tabellen ovan. I den näst sista raden används ett kommatecken som avgränsare. Som ett resultat, när strängen delas, har några av orden inledande mellanslag. På sista raden använde vi ett kommatecken och ett mellanslag som avgränsare. Det är därför det inte fanns några delsträngar med ledande mellanslag i den resulterande arrayen. Detta är bara en subtil detalj som visar hur viktigt det är att noggrant välja rätt avgränsare.

Ledande avgränsare

Detta är en annan viktig nyans. Om den ursprungliga strängen börjar med avgränsaren, kommer det första elementet i den resulterande arrayen att vara en tom sträng. Till exempel skulle det se ut så här: Originalsträng: " Jag älskar Java" Avgränsare: " " Resulterande array: { "", "I", "love", "Java" } Men om den ursprungliga strängen slutar med en avgränsare snarare än att börja med en, då blir resultatet annorlunda: Originalsträng: "Jag älskar Java " Avgränsare: " " Resulterande 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));
    }
}

Huvudmetodens utdata blir så här : Återigen rikta uppmärksamheten mot det faktum att när det första tecknet i den ursprungliga strängen är ett avgränsningstecken, blir resultatet att det första elementet i arrayen blir en tom sträng.

Överbelastat syskon

Klassen String har en annan delad metod med följande signatur:

String[] split(String regex, int limit)

Den här metoden har en extra gränsparameter : den bestämmer hur många gånger regexmönstret kommer att tillämpas på den ursprungliga strängen. Se förklaringarna nedan:

gräns > 0

Mönstret tillämpas limit -1 gånger. Dessutom kommer längden på den returnerade arrayen inte att överstiga värdet på limit -parametern. Det sista elementet i arrayen kommer att vara den del av strängen som följer den sista platsen där avgränsaren hittades. Exempel:

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äns < 0

Det reguljära uttrycket avgränsare tillämpas på strängen så många gånger som möjligt. Den resulterande matrisen kan ha vilken längd som helst. Exempel:

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äns = 0

Som med fallet där limit < 0, appliceras avgränsningsmönstret på strängen så många gånger som möjligt. Den slutliga arrayen kan ha vilken längd som helst. Om de sista elementen är tomma strängar kasseras de från den slutliga arrayen. Exempel:

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

Om vi ​​tittar på implementeringen av versionen med en parameter av splitmetoden, kan vi se att det är som sitt överbelastade syskon, men med det andra argumentet satt till noll:

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

Olika exempel

I den verkliga praktiken händer det ibland att vi har strängar som genereras enligt vissa regler. En sådan sträng kan komma in i vårt program var som helst:

• från en tredjepartstjänst;
• från en begäran skickad till vår server;
• från en konfigurationsfil;
• och så vidare.

I dessa situationer känner programmeraren vanligtvis till "spelets regler". Låt oss säga att en programmerare vet att han eller hon har att göra med användarinformation som lagras enligt detta mönster: Låt oss ta några specifika värden som exempel: Anta att programmerarens uppgift är att skriva en metod som skickar ett e-postmeddelande till användaren. Programmeraren har tillgång till användardata, som registreras i det format som anges ovan. Deluppgiften som vi nu kommer att fortsätta att analysera är hur man isolerar e-postadressen från resten av användardata. Detta är ett fall där splitmetoden kan vara användbar. När allt kommer omkring, om vi tittar på användardatamallen inser vi att att extrahera användarens e-postadress från resten är enkelt som att anropa splitmetoden för att dela strängen. Då kommer e-postadressen att finnas i det sista elementet i den resulterande arrayen. Här är ett exempel på en metod som tar en sträng som innehåller användardata och returnerar användarens e-postadress. För enkelhetens skull, låt oss säga att datasträngen alltid är i det format vi vill ha:

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

Lägg märke till avgränsaren: "\\|" . I reguljära uttryck, "|" är ett specialtecken med speciell betydelse, så om vi vill använda det som ett vanligt tecken (dvs det vi vill hitta i den ursprungliga strängen), måste vi undkomma tecknet med två snedstreck. Tänk på ett annat exempel. Låt oss säga att vi har orderinformation som är strukturerad så här: Eller så kan vi till och med anta några specifika värderingar: Vår uppgift är att beräkna den totala kostnaden för beställningen. Här måste vi tillämpa splitmetoden flera gånger. Det första steget är att dela strängen med ";" som avgränsare för att dela upp den i dess beståndsdelar. Sedan kommer varje resulterande delsträng att innehålla information om en separat produkt, som vi kan bearbeta senare. Sedan, för varje produkt, delar vi upp motsvarande information med hjälp av "," symbolen. Vi tar ett element med ett specifikt index (det där produktpriset lagras) från den resulterande strängarrayen, konverterar den till numerisk form och räknar upp den totala kostnaden för beställningen. Låt oss skriva en metod som gör alla dessa beräkningar:

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 ta reda på hur den här metoden fungerar på egen hand. Baserat på dessa exempel kan vi säga att splitmetoden används när vi har en del data formaterad som en sträng, och vi behöver extrahera viss mer specifik information från den.

Sammanfattning

Vi undersökte splitmetoden för String -klassen. Det är precis vad du behöver när du ska dela en sträng i dess beståndsdelar med hjälp av en speciell avgränsare. Metoden returnerar en array av strängar (delsträngarna som utgör den ursprungliga strängen). Det accepterar ett reguljärt uttryck vars matchningar representerar avgränsningstecknen. Vi undersökte olika subtiliteter av denna metod:

• en ledande avgränsare;
• dess överbelastade syskon med två parametrar.

Vi försökte också modellera några verkliga situationer där vi använde splitmetoden för att lösa hypotetiska, men ganska realistiska, problem.