Kaedah Java String.split().

Mari kita bincangkan tentang kaedah String.split Java : apa yang ia lakukan dan mengapa ia diperlukan. Tidak sukar untuk meneka bahawa ia membelah rentetan Java, tetapi bagaimana ini berfungsi dalam amalan? Mari kita mendalami operasi kaedah dan membincangkan beberapa butiran yang tidak jelas. Pada masa yang sama, kita akan mengetahui berapa banyak kaedah split yang sebenarnya ada pada String . Mari pergi!

Penerangan dan tandatangan untuk String.split Java

Di Java, kaedah split membahagikan rentetan kepada subrentetan menggunakan pembatas yang ditakrifkan menggunakan ungkapan biasa. Mari tunjukkan tandatangan kaedah dan mulakan penyelaman kami:

String[] split(String regex)

Dua perkara jelas daripada tandatangan:

1. Kaedah ini mengembalikan tatasusunan rentetan.
2. Kaedah ini mempunyai parameter input rentetan yang dipanggil regex .

Marilah kita menganalisis setiap perkara ini secara berasingan sambil kita memecahkan penerangan yang diberikan di atas.

1. Kaedah ini mengembalikan tatasusunan rentetan.

   Pengisytiharan mengandungi perkataan berikut: "Di Jawa, kaedah split membahagikan rentetan kepada subrentetan." Kaedah mengumpul subrentetan ini ke dalam tatasusunan yang menjadi nilai pulangan.

2. Kaedah ini mempunyai parameter input rentetan yang dipanggil regex .

   Sekali lagi, ingat perihalan: "memisahkan rentetan kepada subrentetan menggunakan pembatas yang ditakrifkan menggunakan ungkapan biasa." Parameter input regex ialah ungkapan biasa yang digunakan pada rentetan asal. Apabila watak atau gabungan watak sepadan, ia dianggap sebagai pembatas.

Perpecahan Java dalam amalan

Sekarang mari kita mendekati perkara itu. Mari bayangkan kita mempunyai rentetan perkataan. Sebagai contoh, seperti ini: Kita perlu membahagikan rentetan menjadi perkataan. Kami melihat bahawa perkataan dalam rentetan ini dipisahkan antara satu sama lain dengan ruang. Dalam kes ini, watak ruang ialah calon yang sesuai untuk pembatas kami. Kod untuk menyelesaikan tugas kami akan kelihatan seperti ini:

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

Output kaedah utama adalah baris berikut: Mari lihat beberapa lagi contoh cara kaedah split berfungsi: Perhatikan perbezaan antara dua baris terakhir dalam jadual di atas. Dalam baris kedua hingga terakhir, koma digunakan sebagai pembatas. Akibatnya, apabila rentetan dipecah, beberapa perkataan mempunyai ruang utama. Di baris terakhir, kami menggunakan koma dan ruang sebagai pembatas kami. Itulah sebabnya tiada subrentetan dengan ruang utama dalam tatasusunan yang terhasil. Ini hanyalah butiran halus yang menunjukkan betapa pentingnya memilih pembatas yang betul dengan teliti.

Pembatas utama

Ini adalah satu lagi nuansa penting. Jika rentetan asal bermula dengan pembatas, maka elemen pertama tatasusunan yang terhasil akan menjadi rentetan kosong. Sebagai contoh, ia akan kelihatan seperti ini: Rentetan asal: " I love Java" Pembatas: " " Susunan terhasil: { "", "I", "love", "Java" } Tetapi jika rentetan asal berakhir dengan pembatas sebaliknya daripada bermula dengan satu, maka hasilnya akan berbeza: Rentetan asal: "Saya suka Java " Pembatas: " " Susunan terhasil: { "Saya", "cinta", "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));
    }
}

Output kaedah utama adalah seperti ini: Kembalikan perhatian anda kepada fakta bahawa apabila aksara pertama dalam rentetan asal ialah aksara pembatas, maka hasilnya ialah elemen pertama dalam tatasusunan akan menjadi rentetan kosong.

Adik yang terlebih beban

Kelas String mempunyai kaedah split lain dengan tandatangan berikut:

String[] split(String regex, int limit)

Kaedah ini mempunyai parameter had tambahan : ia menentukan berapa kali corak regex akan digunakan pada rentetan asal. Lihat penjelasan di bawah:

had > 0

Corak digunakan had -1 kali. Lebih-lebih lagi, panjang tatasusunan yang dikembalikan tidak akan melebihi nilai parameter had . Elemen terakhir tatasusunan akan menjadi bahagian rentetan yang mengikuti tempat terakhir di mana pembatas ditemui. Contoh:

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

had < 0

Ungkapan biasa pembatas digunakan pada rentetan seberapa banyak yang mungkin. Tatasusunan yang terhasil boleh mempunyai sebarang panjang. Contoh:

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

had = 0

Seperti kes di mana had < 0, corak pembatas digunakan pada rentetan seberapa banyak yang mungkin. Tatasusunan akhir boleh mempunyai sebarang panjang. Jika elemen terakhir adalah rentetan kosong, ia dibuang daripada tatasusunan akhir. Contoh:

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

Jika kita melihat pada pelaksanaan versi satu parameter kaedah split , maka kita dapat melihat bahawa ia adalah seperti adik beradiknya yang terlebih beban, tetapi dengan argumen kedua ditetapkan kepada sifar:

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

Pelbagai contoh

Dalam amalan dunia sebenar, kadangkala berlaku bahawa kita mempunyai rentetan yang dijana mengikut peraturan tertentu. Rentetan sedemikian mungkin masuk ke dalam program kami dari mana-mana sahaja:

• daripada perkhidmatan pihak ketiga;
• daripada permintaan yang dihantar ke pelayan kami;
• daripada fail konfigurasi;
• dan sebagainya.

Dalam situasi ini, pengaturcara biasanya mengetahui "peraturan permainan". Katakan seorang pengaturcara tahu bahawa dia berurusan dengan maklumat pengguna yang disimpan mengikut corak ini: Mari kita ambil beberapa nilai khusus sebagai contoh: Katakan tugas pengaturcara adalah untuk menulis kaedah yang menghantar e-mel kepada pengguna. Pengaturcara mempunyai akses kepada data pengguna, yang direkodkan dalam format yang diberikan di atas. Subtugas yang kini kami akan terus menganalisis ialah cara mengasingkan alamat e-mel daripada data pengguna yang lain. Ini adalah satu contoh di mana kaedah split boleh berguna. Lagipun, jika kita melihat templat data pengguna, kita menyedari bahawa mengekstrak alamat e-mel pengguna daripada yang lain adalah mudah seperti memanggil kaedah split untuk memisahkan rentetan. Kemudian alamat e-mel akan berada dalam elemen terakhir tatasusunan yang terhasil. Berikut ialah contoh kaedah yang mengambil rentetan yang mengandungi data pengguna dan mengembalikan alamat e-mel pengguna. Untuk kesederhanaan, katakan rentetan data sentiasa dalam format yang kita mahu:

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

Perhatikan pembatas: "\\|" . Dalam ungkapan biasa, "|" ialah watak istimewa dengan makna istimewa, jadi jika kita mahu menggunakannya sebagai watak biasa (iaitu apa yang kita mahu cari dalam rentetan asal), maka kita perlu melarikan diri daripada watak itu dengan dua garisan serong terbalik. Pertimbangkan contoh lain. Katakan kami mempunyai maklumat pesanan yang berstruktur seperti ini: Atau kita juga boleh menerima pakai beberapa nilai tertentu: Tugas kami adalah untuk mengira jumlah kos pesanan. Di sini kita perlu menggunakan kaedah split beberapa kali. Langkah pertama ialah membelah rentetan menggunakan ";" sebagai pembatas untuk memecahkannya kepada bahagian komponennya. Kemudian setiap subrentetan yang terhasil akan menyimpan maklumat tentang produk yang berasingan, yang boleh kami proses kemudian. Kemudian, untuk setiap produk, kami akan membahagikan maklumat yang sepadan menggunakan simbol ",". Kami akan mengambil elemen dengan indeks tertentu (yang di mana harga produk disimpan) daripada tatasusunan rentetan yang terhasil, menukarnya kepada bentuk berangka dan mengira jumlah kos pesanan. Mari tulis kaedah yang akan melakukan semua pengiraan ini:

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

Lihat jika anda boleh mengetahui cara kaedah ini berfungsi sendiri. Berdasarkan contoh ini, kita boleh mengatakan bahawa kaedah split digunakan apabila kita mempunyai beberapa data yang diformatkan sebagai rentetan dan kita perlu mengekstrak maklumat tertentu yang lebih khusus daripadanya.

Ringkasan

Kami memeriksa kaedah perpecahan kelas String . Ia hanya apa yang anda perlukan apabila anda perlu membelah rentetan kepada bahagian komponennya dengan bantuan pembatas khas. Kaedah ini mengembalikan tatasusunan rentetan (subrentetan yang terdiri daripada rentetan asal). Ia menerima ungkapan biasa yang padanannya mewakili aksara pembatas. Kami mengkaji pelbagai kehalusan kaedah ini:

• pembatas utama;
• adik beradiknya yang terlebih beban dengan dua parameter.

Kami juga cuba memodelkan beberapa situasi kehidupan sebenar di mana kami menggunakan kaedah split untuk menyelesaikan masalah hipotetikal, tetapi agak realistik.