1. Latar belakang dan analisis keperluan

Dalam pemprosesan data, kita sering menghadapi keperluan untuk menukar data rentetan mentah dalam format tertentu ke dalam jenis koleksi yang lebih mudah untuk dikendalikan. Sebagai contoh, diberi rentetan yang mengandungi pelbagai maklumat bandar, dipisahkan oleh koma, setiap maklumat bandar mengandungi kod kawasan dan nama bandar, dipisahkan dengan $$:

 Data string = "010 $$ fengtai, 010 $$ chaoyang, 010 $$ haidain, 027 $$ wuchang, 027 $$ Hongshan, 027 $$ caidan, 021 $$ changnin, 021 $$ xUHUI, 020 $$ TIANHE";

Matlamat kami adalah untuk mengubahnya menjadi peta >, di mana kunci peta adalah kod kawasan (bahagian sebelum $$), dan nilai (nilai) adalah senarai semua nama bandar di kawasan itu (bahagian selepas $$). Contoh hasil yang diharapkan adalah seperti berikut:

 {
  027 = [Wuchang, Hongshan, Caidan],
  020 = [Tianhe],
  010 = [Fengtai, Chaoyang, Haidain],
  021 = [Changnin, Xuhui]
}

2. Pelaksanaan dan batasan kaedah lelaran tradisional

Sebelum Java 8, atau apabila kita tidak biasa dengan API Stream, kita biasanya menggunakan lelaran gelung tradisional untuk menyelesaikan penukaran tersebut. Berikut adalah contoh pendekatan ini:

 import java.util.arraylist;
import java.util.arrays;
import java.util.hashmap;
import java.util.list;
import java.util.map;

kelas awam tradisionalparser {

    Peta awam <string senarai>> parsedAtatRaditional (string inputData) {
        // Langkah satu: berasingan dengan koma, dan selanjutnya terpisah dengan senarai $$ <string> splitDatalist = arrays.stream (inputData.split (","))
            .map (s -> s.split ("\\ $ \\ $"))
            .kolect (collectors.tolist ()); // Stream masih digunakan di sini, tetapi susulan adalah lelaran tradisional // Langkah 2: Pemprosesan Iteratif dan Pembinaan Peta
        Peta <string senarai>> resultMap = hashmap baru  ();
        untuk (string [] entri: splitdatalist) {
            String kekunci = entri [0];
            Nilai string = entri [1];

            // Periksa sama ada senarai yang sepadan dengan kunci sudah ada dalam senarai peta <string> list = resultMap.get (kekunci);
            jika (senarai == null) {
                // Jika ia tidak wujud, buat senarai baru dan tambahkan senarai elemen = arrayList baru  ();
                list.add (nilai);
                resultMap.put (kunci, senarai);
            } else {
                // Jika ia wujud, tambahkan elemen terus ke senarai senarai yang sedia ada (nilai);
            }
        }
        hasil pulangan;
    }
}</string></string></string></string>

Walaupun kaedah ini dapat mencapai fungsi, ia mempunyai batasan berikut:

• Kod ini verbose : hashmap dan arraylist perlu dibuat secara eksplisit dan mengandungi banyak logik jika else untuk mengendalikan penciptaan senarai dan penambahan elemen.
• Kebolehbacaan yang lemah : Logik perniagaan bertaburan di pelbagai baris kod, menjadikannya sukar untuk melihat niat terasnya -kumpulan dan pemetaan -pada pandangannya.
• Pengaturcaraan Imperatif : memberi tumpuan kepada "bagaimana" dan bukannya "apa", mengurangkan sifat deklaratif kod.

3. Gunakan API Stream Java untuk mencapai penukaran yang cekap

API Stream yang diperkenalkan di Java 8 menyediakan cara yang lebih bersih dan lebih deklaratif untuk bekerja dengan data pengumpulan. Untuk keperluan pengelompokan dan pemetaan dalam contoh ini, pengumpul.groupingby dan pengumpul.Mapping adalah kombinasi yang ideal.

3.1 pengumpul.groupingby dan pengumpul.Mapping

• Pengumpul.groupingby (fungsi Super t ,? extends k> pengelas) : Ini adalah pengumpul yang sangat kuat yang digunakan untuk kumpulan kumpulan dalam aliran berdasarkan fungsi pengelas yang disediakan (pengelas). Ia menukarkan unsur -unsur dalam aliran ke dalam peta >, di mana k adalah kunci yang dikembalikan oleh fungsi pengelas dan senarai adalah senarai semua elemen asal yang dimiliki oleh kunci itu.

• COLLECTORS.GroupingBy (Fungsi Super t ,? Extends k> pengelas, pengumpul Super t, a, d> hiliran) : Ini adalah versi kumpulan yang dibebankan yang membolehkan kita menentukan "pemungut hiliran" (hiliran). Pemungut hiliran ini akan digunakan untuk unsur -unsur di dalam setiap kumpulan, dengan itu mengubah jenis nilai peta. Sebagai contoh, jika anda mahu nilai peta tidak disenaraikan tetapi tetapkan , atau jika kita perlu memetakannya lagi untuk menyenaraikan , anda boleh menggunakan pemungut hiliran.

• Pengumpul.mapping (fungsi Super t ,? extends u> mapper, collector Super u, a, r> hiliran) : pengumpul pemetaan itu sendiri bukan operasi terminal. Ia biasanya digunakan sebagai parameter pemungut lain (seperti pemungut hiliran kumpulan). Fungsinya adalah untuk menukar setiap elemen terlebih dahulu dalam aliran melalui fungsi Mapper, dan kemudian lulus hasil yang ditukar kepada pemungut hilirannya sendiri.

3.2 Percubaan dan Pengoptimuman Awal

Mari semak percubaan aliran asal kami:

 // peta percubaan awal <string senarai>> result = arrays.stream (data.split (","))
    .Collect (collectors.groupingby (s -> s.split ("\\ $ \\ $") [0]));</string>

Masalah dengan percubaan ini adalah bahawa ia hanya menyelesaikan pengelompokan, tetapi jenis nilai peta akan disenaraikan , di mana rentetan adalah rentetan lengkap asal (seperti "010 $$ fengtai"), bukannya senarai yang hanya mengandungi nama bandar seperti yang kita inginkan. Untuk menyelesaikan masalah ini, kita perlu memperkenalkan pemetaan sebagai pemungut hiliran dalam kumpulan:

 import java.util.arrays;
import java.util.list;
import java.util.map;
import java.util.stream.collectors;

Kelas Awam StreamParser {

    peta awam <string senarai>> parsedataStream (string inputData) {
        return arrays.stream (inputData.split (",")) // 1. Pisahkan rentetan asal dengan koma untuk mendapatkan aliran <string>
            .Kollect (collectors.groupingby (
                s -> s.split ("\\ $ \\ $") [0], // 2. Tentukan kunci kumpulan: Gunakan awalan "$$" sebagai kunci
                Pengumpul.mapping (
                    s -> s.split ("\\ $ \\ $") [1], // 3. Tentukan pemetaan nilai: gunakan akhiran "$$" sebagai nilai
                    Pengumpul.tolist () // 4. Tentukan pengumpul hiliran: kumpulkan nilai dipetakan ke dalam senarai)
            ));
    }
}</string></string>

Penyelesaian ini sangat dekat dengan matlamat dan melaksanakan operasi aliran "satu ayat". Walau bagaimanapun, pandangan yang lebih dekat mendedahkan bahawa operasi S.Split ("\\ $ \\ $") dipanggil dua kali dalam kedua -dua fungsi pengelas kumpulan dan fungsi pemetaan pemetaan. Bagi setiap elemen, rentetan dibahagikan dua kali, yang mungkin menanggung sedikit prestasi.

Untuk pengoptimuman selanjutnya, kita boleh terlebih dahulu melakukan pra -proses untuk menukar setiap elemen rentetan asal (seperti "010 $$ fengtai") ke dalam array rentetan (seperti {"010", "fengtai"}), dan kemudian melakukan kumpulan dan pemetaan. Dengan cara ini, operasi perpecahan hanya dilakukan sekali:

 import java.util.arrays;
import java.util.list;
import java.util.map;
import java.util.stream.collectors;

kelas awam OptimisedStreampParser {

    peta awam > parsedataoptimizedstream (string inputData) {
        return arrays.stream (inputData.split (",")) // 1. Pisahkan rentetan asal dengan koma untuk mendapatkan aliran 
            .map (s -> s.split ("\\ $ \\ $")) // 2 preprocessing: Split setiap elemen rentetan ke dalam rentetan [] array.collect (collector.groupingby (
                Sarray -> Sarray [0], // 3. Tentukan kunci pengelompokan: Gunakan elemen pertama array sebagai kunci
                Pengumpul.mapping (
                    Sarray -> Sarray [1], // 4. Tentukan Nilai Pemetaan: Gunakan elemen kedua array sebagai nilai
                    Pengumpul.tolist () // 5. Tentukan pengumpul hiliran: mengumpul nilai dipetakan ke dalam senarai)
            ));
    }

    public static void main (string [] args) {
        Data string = "010 $$ fengtai, 010 $$ chaoyang, 010 $$ haidain, 027 $$ wuchang, 027 $$ Hongshan, 027 $$ caidan, 021 $$ changnin, 021 $$ xUHUI, 020 $$ TIANHE";
        Parser OptimisedStreampParser = baru OptimizedStreampParser ();
        Peta > result = parser.parsedataoptimizedStream (data);
        System.out.println (hasil);
        // output yang dijangkakan: {027 = [Wuchang, Hongshan, Caidan], 020 = [Tianhe], 021 = [Changnin, Xuhui], 010 = [Fengtai, Chaoyang, Haidain]}
    }
}

Paip aliran yang dioptimumkan ini bukan sahaja ringkas, tetapi juga lebih cekap kerana ia mengelakkan operasi pemisahan rentetan berulang.

4. Langkah berjaga -jaga

• Kekukuhan Format Data : Paip aliran di atas mengandaikan bahawa data input dengan ketat mengikuti format nilai $$ utama, nilai $$ kunci. Sekiranya situasi berikut mungkin berlaku dalam data, pemprosesan tambahan diperlukan:
  • Hilang $$ pemisah: s.split ("\\ $ \\ $") [0] atau s.split ("\\ $ \\ $") [1] boleh membuang arrayindexoutofboundsexception.
  • Rentetan kosong atau hanya $$: boleh menyebabkan kekunci atau nilai kosong, atau array keluar dari batas.
  • Multiple $$: Kaedah perpecahan akan berpecah dengan $$ pertama, tetapi jika tingkah laku yang diharapkan adalah berbeza, ungkapan biasa perlu diselaraskan.
  • Unsur -unsur kosong: Sebagai contoh, "010 $$ fengtai ,, 027 $$ wuchang", data.split (",") akan menghasilkan rentetan kosong. Untuk meningkatkan keteguhan, anda boleh menambah penapis atau cuba logik penangkap ke operasi peta, atau melakukan pemeriksaan panjang selepas berpecah. Contohnya:

     .map (s -> s.split ("\\ $ \\ $"))
    .filter (arr -> arr.length == 2) // menapis elemen dengan format yang salah // ... logik kumpulan berikutnya

• Pertimbangan Prestasi : Untuk set data yang sangat besar, operasi terikat API Stream boleh memperkenalkan overhead tertentu. Tetapi dalam senario aplikasi yang paling biasa, kelebihan kesederhanaan kod dan kebolehbacaan jauh melebihi perbezaan prestasi kecil ini. Sekiranya prestasi menjadi kesesakan, penandaarasan harus dilakukan dan pengoptimuman berulang peringkat rendah dapat dipertimbangkan.
• Kebolehbacaan dan kerumitan : Walaupun API Stream menggalakkan operasi "satu ayat", saluran paip aliran yang terlalu kompleks dapat mengurangkan kebolehbacaan kod. Apabila logik menjadi sangat kompleks, pertimbangkan untuk memisahkan operasi aliran ke dalam pelbagai kaedah penolong, atau dalam beberapa kes, gelung tradisional mungkin lebih mudah difahami dan diselenggarakan.

5. Ringkasan

Melalui tutorial ini, kami belajar bagaimana menggunakan API Java Stream, terutamanya gabungan pengumpul.groupingby dan pengumpul.mapping, untuk dengan cekap dan elegan menukar data rentetan dalam format tertentu ke dalam peta >. Berbanding dengan kaedah berulang tradisional, penyelesaian aliran menyediakan kesederhanaan kod yang lebih tinggi, kebolehbacaan dan deklarasi, dan merupakan alat penting untuk memproses data pengumpulan dalam pembangunan Java moden. Pada masa yang sama, kami juga membincangkan bagaimana untuk mengoptimumkan saluran paip aliran melalui pra -proses, dan menekankan keperluan untuk mempertimbangkan keseimbangan antara kekukuhan data dan prestasi dalam aplikasi praktikal. Menguasai teknologi ini akan membantu anda menulis lebih banyak aplikasi Java moden dan berkuasa.