Coffee break #241. Cara Menukar Rentetan kepada Tatasusunan - Panduan Terperinci

Sumber: FreeCodeCamp Dengan tutorial ini, anda akan belajar cara menukar rentetan kepada tatasusunan. Kemahiran ini akan berguna apabila membangunkan aplikasi pemprosesan perkataan atau bekerja dengan data. Rentetan dalam Java ialah sekumpulan aksara, manakala tatasusunan ialah himpunan elemen daripada jenis yang sama. Anda boleh membahagikan rentetan kepada kepingan menggunakan proses penukaran dan kemudian menyimpan kepingan tersebut dalam tatasusunan untuk pemprosesan atau analisis selanjutnya. Terdapat pelbagai kaedah Java untuk menukar rentetan kepada tatasusunan. Mengetahui mereka akan membolehkan anda memilih yang paling sesuai dengan keperluan pengaturcaraan anda.

Bagaimana untuk menukar rentetan kepada tatasusunan menggunakan kaedah toCharArray().

Kaedah toCharArray() ialah fungsi Java terbina dalam yang membolehkan anda menukar rentetan kepada tatasusunan aksara, dan setiap aksara rentetan menjadi elemen tatasusunan. Kaedah ini tersedia dalam kelas String .

Sintaks dan penggunaan kaedah toCharArray():

public class StringToArrayExample {
    public static void main(String[] args) {
        String str = "Hello, World!";

        // Преобразовать строку в массив символов
        char[] charArray = str.toCharArray();

        // Распечатать элементы массива
        for (char c : charArray) {
            System.out.println(c);
        }
    }
}

Penjelasan prosedur:

1. Isytiharkan str pembolehubah rentetan dan tetapkan rentetan yang dikehendaki.
2. Gunakan kaedah toCharArray() pada rentetan str untuk menukarnya kepada tatasusunan aksara. Kaedah ini membahagikan rentetan kepada aksara individu dan mengembalikan tatasusunan yang mengandungi aksara tersebut.
3. Simpan tatasusunan aksara yang terhasil dalam pembolehubah charArray .
4. Lelaran melalui charArray menggunakan gelung untuk setiap untuk mencetak setiap aksara secara individu.

Kesimpulan:

Kelebihan menggunakan toCharArray():

• Kesederhanaan: Kaedah toCharArray() menyediakan cara mudah untuk menukar rentetan kepada tatasusunan aksara dengan hanya satu panggilan kaedah.
• Kebolehbacaan: Tatasusunan aksara yang terhasil boleh diubah suai, dimanipulasi atau diulang dengan mudah melalui gelung.
• Rentetan Tidak Boleh Ubah: Memandangkan rentetan tidak boleh diubah dalam Java, menukarnya kepada tatasusunan aksara boleh berguna apabila anda perlu menukar aksara individu.

Kelemahan menggunakan toCharArray():

• Peningkatan penggunaan memori: Kaedah toCharArray() mencipta tatasusunan aksara baharu, yang memerlukan memori tambahan. Ini boleh menjadi masalah jika anda bekerja dengan rentetan yang besar.
• Prestasi: Mencipta tatasusunan aksara baharu dan menyalin aksara boleh mengakibatkan beberapa kemerosotan prestasi berbanding kaedah lain, terutamanya untuk rentetan panjang.

Bagaimana untuk memisahkan rentetan menggunakan kaedah split().

Kaedah split() dalam Java ialah cara yang mudah untuk memisahkan rentetan kepada tatasusunan subrentetan berdasarkan pembatas yang diberikan. Kaedah ini tersedia dalam kelas String .

Sintaks dan penggunaan kaedah split():

String[] split(String delimiter)

Kaedah ini mengambil pembatas sebagai hujah, yang menentukan titik di mana rentetan harus dibahagikan. Pembatas boleh menjadi ungkapan biasa atau rentetan ringkas. Contoh kod yang menunjukkan penukaran menggunakan split() :

string = "Hello,World,How,Are,You?"
delimiter = ","

split_string = string.split(delimiter)
print(split_string)

Penjelasan prosedur:

1. Kami mentakrifkan pembolehubah rentetan yang dipanggil string . Ia mengandungi teks yang ingin kita pisahkan: “Hello, World, How, Are, You?”
2. Kami menentukan pembatas koma ( , ) yang kami mahu gunakan untuk memisahkan rentetan dan menetapkannya kepada pembolehubah pembatas .
3. Kami kemudian menggunakan kaedah split() pada pembolehubah rentetan , melepasi pembatas sebagai argumen . Ini memisahkan rentetan kepada subrentetan di mana sahaja pembatas ditemui .
4. Kaedah split() mengembalikan senarai subrentetan, yang kami tetapkan kepada pembolehubah split_string .
5. Akhir sekali, kami mencetak senarai split_string untuk melihat hasilnya.

Kesimpulan:

Kebaikan menggunakan split():

• Mudah dan senang digunakan.
• Membolehkan anda memisahkan rentetan berdasarkan pembatas yang ditentukan.
• Menyokong ungkapan biasa sebagai pembatas, menyediakan pilihan pembatas yang fleksibel.

Kelemahan menggunakan split():

• Jika pembatas tidak ditemui dalam rentetan, maka rentetan asal dikembalikan sebagai satu elemen tatasusunan yang terhasil.
• Ungkapan biasa boleh menjadi sukar untuk digunakan dan digunakan secara tidak betul boleh membawa kepada hasil yang tidak dijangka.
• Memisahkan rentetan besar menggunakan ungkapan biasa yang kompleks boleh menjadi mahal dari segi pengiraan.

Bagaimana untuk menukar rentetan kepada tatasusunan menggunakan StringTokenizer

Kelas StringTokenizer di Java ialah kelas warisan yang menyediakan cara mudah untuk tokenize atau pembahagian rentetan kepada token individu. Ia biasanya digunakan untuk menukar rentetan kepada tatasusunan dengan membahagikannya berdasarkan pembatas yang ditentukan.

Sintaks dan penggunaan StringTokenizer:

Untuk menggunakan StringTokenizer , anda perlu mencipta contoh kelas StringTokenizer , menghantar rentetan dan pembatas sebagai parameter:

StringTokenizer tokenizer = new StringTokenizer(inputString, delimiter);

Kod sampel:

import java.util.StringTokenizer;

public class StringToArrayExample {
    public static void main(String[] args) {
        String inputString = "Hello,World,How,Are,You?";

        // Creation an object StringTokenizer с разделителем ","
        StringTokenizer tokenizer = new StringTokenizer(inputString, ",");

        int tokenCount = tokenizer.countTokens();
        String[] stringArray = new String[tokenCount];

        // Преобразование каждого токена в элементы массива
        for (int i = 0; i < tokenCount; i++) {
            stringArray[i] = tokenizer.nextToken();
        }

        // Печать выходного массива
        for (String element : stringArray) {
            System.out.println(element);
        }
    }
}

Penjelasan prosedur:

1. Kod bermula dengan mencipta objek StringTokenizer bernama tokenizer daripada rentetan input dan dibatasi oleh "," .
2. Kaedah countTokens() digunakan untuk mendapatkan jumlah bilangan token yang terdapat dalam rentetan input. Nilai ini disimpan dalam pembolehubah tokenCount .
3. StringArray yang dipanggil dicipta dengan saiz yang sama dengan tokenCount .
4. Kaedah nextToken() digunakan dalam gelung untuk mengulangi setiap token dan memberikannya indeks yang sepadan dalam stringArray .
5. Akhir sekali, gelung for digunakan untuk mencetak setiap elemen dalam fail stringArray .

Kesimpulan:

Aplikasi StringTokenizer

StringTokenizer boleh berguna dalam pelbagai senario, termasuk:

• Menghuraikan data input berstruktur dengan pembatas yang konsisten.
• Mengekstrak perkataan atau komponen individu daripada ayat atau perenggan.
• Mengasingkan nilai yang dipisahkan koma kepada elemen individu.
• Tokenisasi teks untuk analisis leksikal atau tugas pemprosesan bahasa.

Kelebihan menggunakan StringTokenizer:

• Kesederhanaan: Sintaks StringTokenizer adalah mudah dan mudah, menjadikannya boleh diakses oleh pemula.
• Kecekapan: StringTokenizer adalah cekap dari segi memori dan prestasi berbanding dengan ungkapan biasa atau pemisahan berasaskan aksara manual.
• Pembatas fleksibel: Anda boleh menentukan berbilang pembatas atau menggunakan set pembatas yang dipratakrif, membenarkan tokenisasi universal.
• Pemprosesan Berulang: StringTokenizer membolehkan anda memproses token secara berulang, menjadikannya berguna untuk memproses rentetan besar tanpa memuatkan semuanya ke dalam memori sekaligus.

Keburukan menggunakan StringTokenizer:

• Kefungsian terhad: StringTokenizer tidak mempunyai beberapa ciri lanjutan yang terdapat dalam alternatif moden, seperti ungkapan biasa, yang memberikan fleksibiliti yang lebih besar dalam tokenisasi corak kompleks .
• Tiada sokongan untuk ungkapan biasa: Tidak seperti kaedah lain seperti kaedah split() , StringTokenizer tidak boleh menggunakan ungkapan biasa sebagai pembatas, yang mengehadkan keupayaan tokenisasinya.
• Tiada sokongan untuk token kosong: StringTokenizer tidak mengendalikan token kosong secara lalai. Jika anda mempunyai pembatas berturut-turut, ia dianggap sebagai pembatas tunggal, yang boleh membawa kepada hasil yang tidak dijangka.
• Kelas ditamatkan: StringTokenizer ialah sebahagian daripada rangka kerja koleksi Java warisan dan tidak melaksanakan antara muka Iterable , yang bermaksud ia tidak boleh digunakan dalam extended for loops .

Bagaimana untuk menukar secara manual setiap aksara rentetan kepada elemen tatasusunan

Dalam situasi tertentu, anda mungkin memerlukan lebih kawalan ke atas proses penukaran atau ingin menyesuaikannya agar sesuai dengan keperluan khusus anda. Dalam kes sedemikian, anda boleh menukar rentetan kepada tatasusunan dengan mengulang secara manual setiap aksara dalam rentetan dan memberikannya kepada elemen individu dalam tatasusunan. Kod sampel yang menunjukkan penukaran manual:

string = "Hello, World!"
array = []

for char in string:
    array.append(char)

print(array)

Penjelasan prosedur:

1. Kami mentakrifkan rentetan pembolehubah rentetan dengan nilai "Hello, World!" .
2. Kami memulakan senarai kosong yang dipanggil array .
3. Kami menggunakan gelung for untuk mengulangi setiap aksara dalam rentetan .
4. Di dalam gelung, kami menggunakan kaedah append() untuk menambahkan setiap char pada array .
5. Selepas gelung selesai, kami mencetak tatasusunan untuk melihat hasilnya.

Kesimpulan:

Kelebihan penukaran manual:

• Menyediakan kawalan sepenuhnya ke atas proses penukaran.
• Membenarkan aksara untuk disesuaikan atau dimanipulasi sebelum ia diberikan kepada tatasusunan.
• Berfungsi dengan baik apabila anda perlu melakukan operasi tambahan semasa penukaran.

Kelemahan penukaran manual:

• Memerlukan lebih banyak kod dan pemprosesan manual berbanding kaedah terbina dalam seperti toCharArray() atau split() .
• Mungkin kurang cekap untuk rentetan besar kerana proses lelaran manual.
• Meningkatkan risiko ralat jika dilaksanakan secara tidak betul.

Catatan. Anda lebih baik memilih kaedah penukaran manual jika anda perlu melakukan operasi khas semasa proses penukaran. Jika tidak, kaedah terbina dalam seperti toCharArray() atau split() disyorkan untuk kesederhanaan dan kecekapan .

Perbandingan kaedah yang berbeza

toCharArray():

• Kaedah yang mudah dan jelas.
• Mengembalikan tatasusunan aksara yang mewakili rentetan.
• Sesuai untuk penukaran umum tanpa keperluan khas.

split():

• Memisahkan rentetan kepada tatasusunan berdasarkan pembatas yang ditentukan.
• Berguna jika anda perlu membahagikan rentetan kepada subrentetan.
• Memberi fleksibiliti dalam memilih templat pemisah.

StringTokenizer:

• Direka khusus untuk tokenisasi rentetan berasaskan pembatas.
• Membolehkan anda menyesuaikan aksara pembatas.
• Sesuai apabila anda memerlukan kawalan terperinci ke atas proses tokenisasi.

Penukaran manual:

• Menyediakan kawalan sepenuhnya ke atas proses penukaran.
• Membolehkan anda mengkonfigurasi dan melaksanakan operasi tambahan pada simbol.
• Disyorkan jika keperluan khas diperlukan semasa penukaran.

Mengapa anda perlu tahu cara menukar rentetan kepada tatasusunan dalam Java?

Kepentingan penukaran rentetan kepada tatasusunan dalam Java terletak pada fleksibiliti dan fleksibiliti yang ditawarkannya untuk pemprosesan data. Berikut ialah beberapa sebab utama mengapa keupayaan untuk menukar rentetan kepada tatasusunan adalah penting dalam Java:

• Manipulasi data. Tatasusunan menyediakan cara berstruktur untuk menyimpan dan memanipulasi data dalam Java. Dengan menukar rentetan kepada tatasusunan, anda boleh mengakses aksara atau subrentetan individu, mengubah suai data dan melakukan pelbagai operasi seperti mengisih, mencari atau menapis.
• Operasi algoritma. Banyak algoritma dan struktur data dalam Java memerlukan input dalam bentuk tatasusunan. Dengan menukar rentetan kepada tatasusunan, anda boleh menggunakan algoritma ini dengan mudah dan melaksanakan operasi seperti menyusun, membalikkan atau mendapatkan semula elemen tertentu.
• Menghurai dan menganalisis teks. Rentetan selalunya mengandungi data berstruktur atau terhad, seperti CSV (Comma Separated Values) atau JSON (JavaScript Object Notation). Menukar rentetan kepada tatasusunan membolehkan anda memecahkan dan menganalisis data, membenarkan analisis lanjut, pemprosesan atau pengekstrakan maklumat tertentu.
• Manipulasi rentetan. Walaupun rentetan mempunyai set kaedah manipulasi mereka sendiri, tatasusunan menawarkan fleksibiliti tambahan. Menukar rentetan kepada tatasusunan membolehkan anda menggunakan operasi khusus tatasusunan, seperti pengindeksan, penghirisan atau penyatuan, untuk mengurus data dengan lebih cekap atau memenuhi keperluan pemformatan tertentu.
• Keserasian: Dalam sesetengah senario, anda mungkin perlu menukar rentetan kepada tatasusunan untuk berinteraksi dengan perpustakaan atau API yang mengharapkan input berasaskan tatasusunan. Dengan melakukan penukaran, anda boleh menyepadukan data rentetan anda dengan komponen luaran dengan mudah, memastikan keserasian dan membolehkan pertukaran data yang lancar.

Kesimpulan

Dalam artikel ini, kami telah membincangkan pelbagai kaedah untuk menukar rentetan kepada tatasusunan dalam Java. Anda mempelajari tentang empat cara berbeza: menggunakan kaedah toCharArray() , membelah rentetan menggunakan kaedah split() , menggunakan StringTokenizer dan menukar setiap aksara secara manual kepada elemen tatasusunan. Kami telah membincangkan setiap kaedah secara terperinci, termasuk sintaks, penggunaan, kod sampel, kebaikan dan keburukan mereka.