Split method sa Java: hatiin ang isang string sa mga bahagi

Pag-usapan natin ang String split method : ano ang ginagawa nito at bakit ito kailangan. Madaling hulaan na hinahati nito ang string, ngunit paano ito gumagana sa pagsasanay? Tingnan natin kung paano gumagana ang pamamaraan at talakayin ang ilang hindi halatang mga detalye, at sa parehong oras alamin kung gaano karaming mga split method ang mayroon talaga sa String class. Tara na!

Kahulugan at lagda para sa Java String.split

Hinahati ng split method sa Java ang isang string sa mga substring gamit ang delimiter na tinukoy gamit ang isang regular na expression. Bigyan natin ang paraan ng lagda at simulan ang ating pagsisid:

String[] split(String regex)

Dalawang bagay ang malinaw sa pirma:

1. Ang pamamaraan ay nagbabalik ng isang hanay ng mga string.
2. Ang pamamaraan ay tumatagal ng isang regex string bilang isang parameter.

Tingnan natin ang bawat bagay nang hiwalay sa mga tuntunin ng kahulugan na ibinigay sa itaas.

1. Ang pamamaraan ay nagbabalik ng isang hanay ng mga string.

   Ang kahulugan ay naglalaman ng mga sumusunod na salita: "Ang split method sa Java ay naghahati ng string sa mga substring." Ang mga substring na ito ay kinokolekta ng pamamaraan sa isang array at kumakatawan sa return value nito.

2. Ang pamamaraan ay tumatagal ng isang regex string bilang isang parameter.

   Muli, tandaan ang kahulugan: "naghahati ng isang string sa mga substring gamit ang isang delimiter na tinukoy gamit ang isang regular na expression." Ang tinatanggap na parameter ng regex ay isang regular na pattern ng expression na inilalapat sa source string at tumutugma sa delimiter character (o kumbinasyon ng mga character) sa source string.

Hatiin sa pagsasanay

Ngayon ay bumaba tayo sa negosyo. Isipin natin na mayroon tayong tali sa mga salita. Halimbawa, tulad nito: Kailangan nating putulin ang string sa mga salita. Nakikita natin na sa linyang ito ang mga salita ay pinaghihiwalay ng mga puwang sa bawat isa. Ang espasyo ay isang perpektong kandidato para sa separator role sa kasong ito. Ito ang hitsura ng code para sa paglutas ng problemang ito:

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

Ang output ng pangunahing pamamaraan ay ang mga sumusunod na linya: Tingnan natin ang ilang higit pang mga halimbawa kung paano gagana ang split method : Pansinin ang mga pagkakaiba sa pagitan ng huling dalawang hilera sa talahanayan sa itaas. Sa penultimate na linya, ang delimiter ay isang kuwit, kaya ang linya ay nahahati sa paraang ang ilang salita ay may mga nangungunang puwang. Sa huling linya, gumamit kami ng kuwit at space character bilang delimiter. Samakatuwid, ang resultang array ay hindi naglalaman ng anumang mga linya na may mga nangungunang puwang. Ito ay isang maliit na detalye lamang na nagpapakita kung gaano kahalaga ang maingat na piliin ang tamang separator.

Nangungunang delimiter

May isa pang mahalagang nuance. Kung ang source string ay nagsisimula sa isang delimiter, ang unang elemento ng magreresultang array ay ang walang laman na string. Sa isang halimbawa, magiging ganito ang hitsura: Source string: "I love Java" Delimiter: " " Resultang array: { "" , "I" , "love" , "Java" } Ngunit kung ang source string ay nagtatapos sa isang delimiter at hindi magsisimula, mag-iiba ang resulta: Source string: "I love Java" Separator: " " Resultang array: { "I" , "love" , "Java" } Tinitingnan namin ang code sa mga variation ng split method na may separator character sa dulo at/o simula ng source string :

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

Ang output ng pangunahing pamamaraan ay magiging ganito: Tandaan muli na kapag ang unang character sa source string ay isang delimiter character, ang magreresultang array ay magkakaroon ng walang laman na string bilang unang elemento nito.

Overloaded na kapwa

Ang String class ay may isa pang split method na may ganitong lagda:

String[] split(String regex, int limit)

Ang pamamaraang ito ay may karagdagang parameter ng limitasyon : tinutukoy nito ang dami ng beses na ilalapat ang pattern ng regex sa source string. Nasa ibaba ang mga paliwanag:

limitasyon > 0

limitasyon -1 beses ay inilapat . Sa kasong ito, ang haba ng array ay hindi lalampas sa limitasyon na halaga . Ang huling elemento ng array ay magiging bahagi ng string kasunod ng huling delimiter na natagpuan. Halimbawa:

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

limitasyon < 0

Ang pattern ng paghahanap ng delimiter ay inilalapat sa string nang maraming beses hangga't maaari. Ang haba ng resultang array ay maaaring anuman. Halimbawa:

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

limitasyon 0

Tulad ng limitasyon < 0, ang delimiter pattern ay inilalapat sa string nang maraming beses hangga't maaari. Ang resultang array ay maaaring kahit anong haba. Kung ang mga huling elemento ay katumbas ng walang laman na string, itatapon ang mga ito sa huling hanay. Halimbawa:

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

Kung titingnan natin ang pagpapatupad ng split method na may isang argumento, makikita natin na tinatawag ng pamamaraang ito ang overloaded na kapatid nito na may pangalawang argumento na zero:

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

Iba't ibang halimbawa

Sa pagsasanay sa pagtatrabaho, kung minsan ay nangyayari na mayroon kaming isang linya na naipon ayon sa ilang mga patakaran. Ang linyang ito ay maaaring "pumunta" sa aming programa mula sa kahit saan:

• mula sa isang third-party na serbisyo;
• mula sa isang kahilingan sa aming server;
• mula sa file ng pagsasaayos;
• atbp.

Kadalasan sa ganitong sitwasyon ay alam ng programmer ang "mga panuntunan ng laro". Sabihin nating alam ng programmer na mayroon siyang impormasyon tungkol sa user, na nakaimbak ayon sa pattern na ito: Halimbawa, kumuha tayo ng mga partikular na halaga: At ngayon ang programmer ay nahaharap sa gawain: upang magsulat ng isang paraan na nagpapadala ng isang email sa gumagamit. Sa kanyang pagtatapon ay impormasyon tungkol sa gumagamit, na naitala sa format sa itaas. Well, ang subtask na patuloy naming susuriin ay upang ihiwalay ang email address mula sa pangkalahatang impormasyon tungkol sa user. Ito ay isang halimbawa kung saan maaaring maging kapaki-pakinabang ang split method . Pagkatapos ng lahat, kung titingnan namin ang template, naiintindihan namin na upang kunin ang email address ng user mula sa lahat ng impormasyon, kailangan lang naming hatiin ang linya gamit ang split method . Pagkatapos ang email address ay nasa huling elemento ng magreresultang array. Magbigay tayo ng halimbawa ng ganoong paraan, na kumukuha ng string na naglalaman ng impormasyon tungkol sa user at ibinabalik ang email ng user. Upang pasimplehin, ipagpalagay natin na ang string na ito ay palaging tumutugma sa format na kailangan natin:

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

Tandaan ang separator: "\\|" . Dahil sa mga regular na expression na "|" - ito ay isang espesyal na karakter kung saan ang ilang partikular na lohika ay nakatali; upang magamit ito bilang isang regular (ang isa na gusto nating hanapin sa pinagmulang string), kailangan nating takasan ang karakter na ito gamit ang dalawang backslashes. Tingnan natin ang isa pang halimbawa. Sabihin nating mayroon kaming impormasyon tungkol sa isang order, na nakasulat sa humigit-kumulang na format na ito: O kumuha tayo ng mga partikular na halaga: Kami ay nahaharap sa gawain ng pagkalkula ng kabuuang halaga ng order. Dito kailangan nating gamitin ang split method nang maraming beses. Ang unang hakbang ay hatiin ang string sa pamamagitan ng simbolo na ";" sa mga bahaging bahagi nito. Pagkatapos sa bawat bahaging iyon ay magkakaroon tayo ng impormasyon tungkol sa isang indibidwal na produkto, na maaari nating iproseso sa hinaharap. At pagkatapos, sa loob ng bawat produkto, paghihiwalayin namin ang impormasyon gamit ang simbolo na "," at kukuha mula sa resultang array ang isang elemento na may isang tiyak na index (kung saan naka-imbak ang presyo), i-convert ito sa isang numeric na form at i-compile ang panghuling gastos ng utos. Sumulat tayo ng isang paraan na kalkulahin ang lahat ng ito:

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

Subukang alamin para sa iyong sarili kung paano gumagana ang pamamaraang ito. Batay sa mga halimbawang ito, maaari naming sabihin na ang split method ay ginagamit kapag mayroon kaming ilang impormasyon sa string form, kung saan kailangan naming kumuha ng ilang mas partikular na impormasyon.

Mga resulta

Tiningnan namin ang split method ng String class . Kinakailangang hatiin ang isang string sa mga bahaging bahagi nito gamit ang isang espesyal na delimiter. Ang pamamaraan ay nagbabalik ng isang hanay ng mga string (ang mga bahagi ng isang string). Tumatanggap ng regular na expression na nakakahanap ng (mga) character ng delimiter. Tiningnan namin ang iba't ibang mga subtleties ng pamamaraang ito:

• nangungunang karakter ng delimiter;
• overloaded kapatid na may dalawang argumento.

Sinubukan din naming gayahin ang ilang "tunay na buhay" na mga sitwasyon kung saan ginamit namin ang split method upang malutas kahit na kathang-isip, ngunit medyo makatotohanang mga problema.