Java String.split() na pamamaraan

Pag-usapan natin ang String.split method ng Java: kung ano ang ginagawa nito at bakit ito kailangan. Hindi mahirap hulaan na hinahati nito ang isang string ng Java, ngunit paano ito gumagana sa pagsasanay? Sumisid tayo nang malalim sa pagpapatakbo ng pamamaraan at talakayin ang ilang mga di-halatang detalye. Kasabay nito, malalaman natin kung gaano karaming mga split method ang mayroon ang String . Tara na!

Paglalarawan at lagda para sa String.split ng Java

Sa Java, hinahati ng split method ang isang string sa mga substring gamit ang delimiter na tinukoy gamit ang isang regular na expression. Ipakita natin ang lagda ng pamamaraan 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 may string input parameter na tinatawag na regex .

Pag-aralan natin ang bawat isa sa mga ito nang hiwalay habang hinahati natin ang paglalarawang ibinigay sa itaas.

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

   Ang deklarasyon ay naglalaman ng mga sumusunod na salita: "Sa Java, hinahati ng split method ang isang string sa mga substring." Kinokolekta ng pamamaraan ang mga substring na ito sa isang array na nagiging halaga ng pagbabalik.

2. Ang pamamaraan ay may string input parameter na tinatawag na regex .

   Muli, alalahanin ang paglalarawan: "naghahati ng isang string sa mga substring gamit ang isang delimiter na tinukoy gamit ang isang regular na expression." Ang regex input parameter ay isang regular na expression na inilalapat sa orihinal na string. Kapag tumugma ang karakter o kumbinasyon ng mga character, ituturing ang mga ito bilang isang delimiter.

Ang paghahati ng Java sa pagsasanay

Ngayon, lumapit tayo sa punto. Isipin natin na mayroon tayong isang string ng mga salita. Halimbawa, tulad nito: Kailangan nating hatiin ang string sa mga salita. Nakikita natin na ang mga salita sa string na ito ay pinaghihiwalay ng mga puwang sa isa't isa. Sa kasong ito, isang space character ang perpektong kandidato para sa aming delimiter. Ang code para sa paglutas ng aming gawain ay magiging ganito:

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 ilan pang halimbawa kung paano gagana ang split method: Pansinin ang mga pagkakaiba sa pagitan ng huling dalawang hilera sa talahanayan sa itaas. Sa pangalawa hanggang sa huling hilera, ginagamit ang kuwit bilang delimiter. Bilang resulta, kapag nahati ang string, may mga nangungunang puwang ang ilan sa mga salita. Sa huling hilera, gumamit kami ng kuwit at puwang bilang aming delimiter. Iyon ang dahilan kung bakit walang mga substring na may mga nangungunang puwang sa resultang array. Ito ay isang banayad na detalye lamang na nagpapakita kung gaano kahalaga ang maingat na piliin ang tamang delimiter.

Nangungunang delimiter

Ito ay isa pang mahalagang nuance. Kung ang orihinal na string ay nagsisimula sa delimiter, ang unang elemento ng resultang array ay isang walang laman na string. Halimbawa, magiging ganito ang hitsura: Orihinal na string: " I love Java" Delimiter: " " Resultang array: { "", "I", "love", "Java" } Ngunit kung ang orihinal na string ay nagtatapos sa isang delimiter sa halip kaysa sa simula sa isa, pagkatapos ay magiging iba ang resulta: Orihinal na string: "Mahal ko ang Java " Delimiter: " " Resultang 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));
    }
}

Ang output ng pangunahing pamamaraan ay magiging ganito: Muli mong ibaling ang iyong pansin sa katotohanan na kapag ang unang character sa orihinal na string ay isang delimiter na character, ang resulta ay ang unang elemento sa array ay isang walang laman na string.

Overloaded na kapatid

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

String[] split(String regex, int limit)

Ang pamamaraang ito ay may karagdagang parameter ng limitasyon : tinutukoy nito kung gaano karaming beses ilalapat ang pattern ng regex sa orihinal na string. Tingnan ang mga paliwanag sa ibaba:

limitasyon > 0

Ang pattern ay inilapat sa limitasyon -1 beses. Higit pa rito, ang haba ng ibinalik na hanay ay hindi lalampas sa halaga ng parameter ng limitasyon . Ang huling elemento ng array ay ang bahagi ng string na sumusunod sa huling lugar kung saan natagpuan ang delimiter. 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 delimiter na regular na expression ay inilalapat sa string nang maraming beses hangga't maaari. Ang resultang array ay maaaring magkaroon ng anumang haba. Halimbawa:

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

limitasyon = 0

Tulad ng kaso kung saan ang limitasyon < 0, ang delimiter pattern ay inilalapat sa string nang maraming beses hangga't maaari. Ang huling hanay ay maaaring magkaroon ng anumang haba. Kung ang mga huling elemento ay walang laman na mga string, itatapon ang mga ito mula sa huling hanay. Halimbawa:

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

Kung titingnan natin ang pagpapatupad ng isang-parameter na bersyon ng split method, makikita natin na ito ay tulad ng overloaded na kapatid nito, ngunit sa pangalawang argumento ay nakatakda sa zero:

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

Iba't ibang halimbawa

Sa real-world practice, minsan nangyayari na mayroon tayong mga string na nabuo ayon sa ilang partikular na panuntunan. Ang ganitong string ay maaaring pumasok sa aming programa mula sa kahit saan:

• mula sa isang third-party na serbisyo;
• mula sa isang kahilingang ipinadala sa aming server;
• mula sa isang configuration file;
• at iba pa.

Sa mga sitwasyong ito, karaniwang alam ng programmer ang "mga panuntunan ng laro". Sabihin nating alam ng isang programmer na siya ay nakikitungo sa impormasyon ng user na nakaimbak ayon sa pattern na ito: Kunin natin ang ilang partikular na halaga bilang isang halimbawa: Ipagpalagay na ang gawain ng programmer ay magsulat ng isang paraan na nagpapadala ng email sa user. Ang programmer ay may access sa data ng user, na naitala sa format na ibinigay sa itaas. Ang subtask na patuloy naming susuriin ngayon ay kung paano ihiwalay ang email address mula sa natitirang data ng user. Ito ay isang pagkakataon kung saan maaaring maging kapaki-pakinabang ang split method. Pagkatapos ng lahat, kung titingnan namin ang template ng data ng user, napagtanto namin na ang pagkuha ng email address ng user mula sa iba ay isang simpleng pagtawag sa split method para hatiin ang string. Pagkatapos ang email address ay nasa huling elemento ng magreresultang array. Narito ang isang halimbawa ng paraan na kumukuha ng string na naglalaman ng data ng user at ibinabalik ang email address ng user. Para sa pagiging simple, sabihin natin na ang string ng data ay palaging nasa format na gusto 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]
    }
}

Pansinin ang delimiter: "\\|" . Sa mga regular na expression, "|" ay isang espesyal na karakter na may espesyal na kahulugan, kaya kung gusto nating gamitin ito ng isang ordinaryong karakter (ibig sabihin, kung ano ang gusto nating hanapin sa orihinal na string), kailangan nating takasan ang karakter na may dalawang backslashes. Isaalang-alang ang isa pang halimbawa. Sabihin nating mayroon kaming impormasyon ng order na nakaayos tulad nito: O maaari tayong magpatibay ng ilang partikular na halaga: Ang aming gawain ay kalkulahin ang kabuuang halaga ng order. Dito kailangan nating ilapat ang split method nang maraming beses. Ang unang hakbang ay hatiin ang string gamit ang ";" bilang delimiter upang hatiin ito sa mga bahaging bahagi nito. Pagkatapos, ang bawat resultang substring ay magtataglay ng impormasyon tungkol sa isang hiwalay na produkto, na maaari naming iproseso sa ibang pagkakataon. Pagkatapos, para sa bawat produkto, hahatiin namin ang kaukulang impormasyon gamit ang simbolo na ",". Kukuha kami ng isang elemento na may partikular na index (ang isa kung saan naka-imbak ang presyo ng produkto) mula sa nagreresultang string array, i-convert ito sa numerical form, at italy up ang kabuuang halaga ng order. Sumulat tayo ng isang paraan na gagawa ng lahat ng mga kalkulasyong ito:

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

Tingnan kung maaari mong malaman kung paano gumagana ang pamamaraang ito sa iyong sarili. Batay sa mga halimbawang ito, masasabi nating ginagamit ang split method kapag mayroon kaming ilang data na naka-format bilang string, at kailangan naming kumuha ng ilang partikular na impormasyon mula rito.

Buod

Sinuri namin ang split method ng String class. Ito lang ang kailangan mo kapag kailangan mong hatiin ang isang string sa mga bahaging bahagi nito sa tulong ng isang espesyal na delimiter. Ang pamamaraan ay nagbabalik ng isang hanay ng mga string (ang mga substring na binubuo ng orihinal na string). Tumatanggap ito ng isang regular na expression na ang mga tugma ay kumakatawan sa (mga) karakter ng delimiter. Sinuri namin ang iba't ibang mga subtleties ng pamamaraang ito:

• isang nangungunang delimiter;
• overloaded na kapatid nito na may dalawang parameter.

Sinubukan din naming magmodelo ng ilang sitwasyon sa totoong buhay kung saan ginamit namin ang split method upang malutas ang hypothetical, ngunit medyo makatotohanan, mga problema.