Apa itu dan mengapa itu penting – Beragampengetahuan

JAva 8, Diterbitkan lebih dari sepuluh tahun yang lalu, merupakan tonggak penting. Dalam rilis ini, Java melakukan perubahan mendasar dari pemrograman berorientasi objek (OOP) murni menjadi kombinasi OOP dan pemrograman fungsional (FP). Untuk mencapai tujuan ini, Java 8 mendukung lambda, stream API, dll. sebagai fitur bahasa inti.

Antarmuka media streaming Dipengaruhi dan dimodelkan oleh saluran pengumpulan. Aliran yang khas memiliki tiga tahap, yaitu sumber, operasi perantara, Dan Operasi terminal.

• satu sumber Itu adalah sesuatu yang sudah memiliki atau menghasilkan faktor-faktor konsumsi. Ini mungkin koleksi yang sudah terisi sebelumnya, mis. Listatau a Set. Alternatifnya, seseorang dapat menghasilkan aliran, mis. Stream.of atau Stream.generate Metode pabrik.
• operasi perantara Adalah API untuk mengubah atau memfilter elemen yang disediakan oleh sumber. Misalnya, filter ,map, sort, distinct dll. bisa jadi tanpa kewarganegaraan atau penuh keadaan, Tergantung pada sifat operasi yang dilakukannya.
• Operasi terminal adalah tahap akhir dari pipa aliran, yang menghasilkan hasil akhir atau efek samping. Setelah dipanggil, operasi terminal menutup aliran dan mencegah penggunaan kembali. Misalnya, reduce , collect, count, min/maxDLL.

Meskipun kuat, Stream API telah lama dibatasi—pengembang hanya dapat melakukan penyesuaian terminal Penggunaan operasional Collector. Operasi perantara diperbaiki – sejauh ini.

Di Java 24, stream collector muncul sebagai tambahan yang mengubah permainan. Mereka mengizinkan pengembang untuk mendefinisikan Sesuaikan operasi perantarahasilkan lebih banyak Ekspresif, dapat digunakan kembali, Dan Saluran pipa streaming yang efisien. Sebelumnya, logika khusus seperti ini diperlukan solusi yang diperlukan atau Pasca pemrosesan – Seringkali rumit dan tidak efisien. Gatherer Menjembatani kesenjangan ini, menyediakan Kelas satu, dapat disusun Cara untuk memperluas model aliran tanpa mempengaruhi keterbacaan atau kinerja.

pengumpul

definisi

Dari dokumen itu sendiri, Gatherer Didefinisikan sebagai:

satu pengumpul adalah operasi perantara mengubah satu Mengubah aliran elemen masukan menjadi aliran elemen keluaranditerapkan secara opsional tindakan terakhir ketika mencapai akhir aliran Elemen masukan.

intinya Gatherer Anda dapat melakukan hal berikut:

• Ubah elemen menjadi a Satu-ke-satu, satu-ke-banyak, banyak-ke-satu, atau banyak-ke-banyak Mode.
• Melacak elemen yang terlihat sebelumnya Pengaruh Transformasi elemen selanjutnya.
• hubungan pendekatau berhenti memproses elemen masukan untuk mengubah aliran tak terbatas menjadi aliran terbatas.
• Proses aliran secara paralel.

Sederhananya, a Gatherer Sama seperti operasi perantara Collector Digunakan untuk operasi terminal.

detail

Misalkan kita perlu mengiris aliran berukuran tetap 3 dan batasi output ke nilai maksimum 2 mengiris.

Input  => 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Output => [0, 1, 2], [3, 4, 5] 

Untuk streaming API yang sudah ada, salah satu cara implementasinya ada di Pasca pemrosesan, IArtinya, kumpulkan semua elemen aliran, pantau elemen dan jendela sebelumnya, dan hasilkan keluaran. Kode yang dihasilkan terlihat seperti ini Cukup rumit dan tidak intuitif Dan Sulit untuk dipahami atau dipertahankan.

IntStream.range(0, 10)
         .boxed()
         .limit(3 * 2) // window size * number of windows
         .collect(Collector.of(
                        () -> new ArrayList<ArrayList<Integer>>(),
                        (groups, element) ->  groups.getLast().size() == 3) 
                                var current = new ArrayList<Integer>();
                                current.add(element);
                                groups.addLast(current);
                             else 
                                groups.getLast().add(element);
                            
                        ,
                        (left, right) -> 
                            throw new UnsupportedOperationException("Cannot be parallelized");
                        
                ))
          .forEach(System.out::println);

bawaan Gatheres.windowFixed Hal yang sama dapat dicapai dengan cara berikut Bersih, sederhana dan intuitif Dan dapat dipelihara Kodenya adalah sebagai berikut.

IntStream.range(0, 10)
         .boxed()
         .gather(Gatherers.windowFixed(3))
         .limit(2)
         .forEach(System.out::println);

Kolektor bawaan

Karena tidak semua kasus penggunaan dapat ditambahkan sebagai API streaming Jaga agar tetap bisa dipelajari Dan Penemuan APIJava memiliki bawaan berikut ini Gatherers Mengatasi kasus penggunaan umum.

jendela tetap

Seperti yang ditunjukkan pada bagian sebelumnya, ini mengumpulkan elemen ke dalam jendela berukuran tetap. Jika aliran kosong, tidak ada jendela yang akan dibuat. Jendela terakhir mungkin berisi elemen lebih sedikit dari ukuran jendela yang disediakan. Jendela menjaga urutan elemen yang ditemukan.

jendela geser

Ini akan mengumpulkan elemen ke dalam jendela ukuran tertentudimana setiap jendela berikutnya berisi semua elemen jendela sebelumnya kecuali yang terbarudan menambahkan elemen berikutnya ke aliran. jika alirannya kosong maka tidak ada jendela akan diproduksi. Jika ukuran aliran lebih kecil dari ukuran jendela, hanya jendela yang dihasilkan yang berisi semua elemen dalam aliran. penahan jendela perintah pertemuan elemen.

Input  => 0, 1, 2, 3, 4, 5

Gatherers.windowSliding(3)

Output => [0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]

melipat

Ini melakukan a Sudah dipesan, mirip dengan restorasitransformasi selain operasional terminal; Dan TIDAK hasil antara. Berguna jika pengurangan menengah diperlukan dan komputasi aliran perlu dilanjutkan.

Misalnyagabungkan aliran karakter dan ubah menjadi huruf besar, yang dapat diterapkan sebagai berikut →

List.of("a", "b", "c", "d", "e")
    .stream()
    .gather(Gatherers.fold(() -> "", String::concat))
    .map(String::toUpperCase)
    .forEach(System.out::println);

Output => ABCDE

catatan:

• Sejak a stream.gather Kembali a stream Itu sendiri dapat dimanipulasi lebih lanjut hingga operasi terminal dipanggil. Berbeda dengan operasi pengurangan, operasi pengurangan akan menghentikan dan menutup aliran.
• Secara semantik, contoh ini dapat dicapai dengan yang ada API streamingnya adalah sebagai berikut – tetapi memang demikian Tidak efisien.

List.of("a", "b", "c", "d", "e")
    .stream()
    .map(String::toUpperCase) // operates on each element
    .reduce(String::concat)
    .ifPresent(System.out::println);

Output => ABCDE

pemindaian

Ini akan melakukan pemindaian awalan (akumulasi tambahan) menggunakan fungsionalitas yang disediakan. Mulai dari nilai awal, setiap nilai selanjutnya diperoleh dengan mengakumulasi nilai saat ini dan elemen masukan berikutnya. scan Perbedaannya adalah fold dalam arti tertentu scan Menghasilkan hasil pengurangan menengah.

Misalnyamenggabungkan aliran karakter dan mengubahnya menjadi huruf besar dapat diterapkan sebagai berikut (Ada juga hasil antara):

List.of("a", "b", "c", "d", "e")
    .stream()
    .gather(Gatherers.scan(() -> "", String::concat))
    .map(String::toUpperCase)
    .forEach(System.out::println);

Output => A, AB, ABC, ABCD, ABCDE

Ini umumnya berguna untuk pemrosesan apa pun hasil antara Juga diperlukan. Misalnyalaporan bank yang mencerminkan saldo rekening setelah setiap transaksi.

Konkurensi peta

Mirip dengan map Operasi, tetapi dijalankan secara bersamaan pada tingkat konkurensi maksimum yang ditentukan menjaga urutan aliran. Perlu diingat bahwa jika ditemukan pengecualian atau aliran dihentikan sebelum waktunya, tugas pemetaan yang sedang berlangsung akan dibatalkan Dasar untuk melakukan yang terbaik. Oleh karena itu, pembuat peta yang disediakan harus tahan terhadap pembatalan.

Terlebih lagi, meskipun parallelStream Memanfaatkan kumpulan koneksi bercabang publik, mapConcurrent Gunakan thread virtual untuk eksekusi. Oleh karena itu, sering kali berguna jika mapper melibatkan panggilan I/O (menggunakan thread virtual dapat membawa banyak manfaat).

Kolektor khusus

Sama Collector Antarmuka dapat digunakan untuk operasi terminal khusus apa pun, Gatherer Antarmuka juga dapat mengimplementasikan operasi perantara khusus apa pun.

Namun, sebelum menerapkan penyesuaian apa pun Gatherer Perhatikan hal berikut →

• Sebagian besar kasus penggunaan sudah tersedia dengan operasi aliran perantara yang ada, cobalah untuk terlebih dahulu mencoba solusi yang memanfaatkannya – pertimbangkan semua aspek, yaitu. Keterbacaan, kemudahan pemahaman dan pemeliharaan, kinerja, dll.
• Jika hal di atas tidak cukup, periksa yang bawaan Gatherers lebah.
• Atau disesuaikan Gatherer Merasa perlu, berhentilah dan pikirkan berapa kali kita benar-benar menggunakan penyesuaian Collector sekali!

pendeknya — Gunakan adat Gatherer hanya sebagai upaya terakhir Dan Berhati-hatilah. Ingat – hanya karena kita bisa, kita tidak boleh melakukannya!

pengetahuan dasar

Berikut adalah beberapa hal dasar yang harus diketahui pengembang sebelum melakukan penyesuaian Gatherer →

mengalir

Data mengalir dalam aliran turun Sambil mengendalikan lalu lintas ke atas. Artinya, setelah operasi perantara/terminal memenuhi kondisi opsional apa pun, operasi tersebut memberi sinyal ke hulu untuk berhenti mendorong lebih banyak data. Misalnya, limit, findFirst, findAny, takeWhile, dropWhileDan seterusnya, setelah kondisi yang ditentukan terpenuhi, sinyal dikirim ke hulu untuk berhenti mengirimkan lebih banyak elemen. Ini mungkin saja penuh keadaan atau tanpa kewarganegaraan Operasi juga.

panggung: setiap Gatherer mewakili a saluran pipa panggung Hasil berikut harus dicapai

1. menerima elemen (data) untuk ditangani.
2. Elemen proses.
3. Opsional Ubah elemen dan dorong ke hilir.
4. Tanyakan di bagian hilir apakah diperlukan lebih banyak elemen dan teruskan detail ini ke bagian hulu (kontrol).

fitur:

• Gatherer.of(..) berarti aliran berjalan berurutan atau paralel Masing-masing – seperti yang diwakili saat dipakai.
• Gatherer.ofSequential(..) berarti aliran berjalan Urutan dalam aliran paralel – Penting untuk proses penegakan hukum, terutama ketika itu Berstatus. Kedua.G., distinct, sorted DLL.
• satu Gatherer Tergantung pada kerumitan pemrosesannya, ini dapat dibagi menjadi salah satu dari empat jenis berikut. Yang paling kiri adalah yang termudah, dengan kesulitan yang semakin meningkat seiring Anda bergerak ke kanan. Oleh karena itu, pilihlah a Gatherer Miliki untuk kiri cobalah yang terbaik.

kontrak:

satu Gatherer Terdiri dari empat fungsi →

1. Penginisialisasi (opsional) — disediakan a objek swasta negara Digunakan selama pemrosesan aliran untuk mengingat elemen sebelumnya untuk perbandingan.
2. Integrator (wajib) — Memproses setiap elemen masukan yang dapat mengeluarkan nol atau lebih elemen keluaran melalui a Downstream Tujuan. Itu juga dapat menyebabkan arus pendek dengan kembali false.
3. Penggabung (opsional) — Mendukung pemrosesan aliran paralel dengan menggabungkan objek status. Jika dihilangkan, kolektor akan berjalan secara berurutan bahkan dalam aliran paralel. Berguna untuk operasi asosiatif seperti penjumlahan atau pengumpulan.
4. Penyelenggara (opsional) — Dipanggil setelah semua elemen diproses. Itu dapat mengeluarkan hasil akhir atau melakukan pembersihan.

Harus tahu cara menelepon Stream.gather(gatherer) Bekerja selangkah demi selangkah →

1. satu Downstream Buat objek untuk meneruskan keluaran ke tahap berikutnya.
2. ini initializer Buat objek keadaan.
3. ini integrator Setiap elemen masukan diproses, kemungkinan mengeluarkan keluaran.
4. jika integrator kembali falsestreaming segera dihentikan.
5. Setelah semua elemen, finisher (jika ada) dipanggil.

contoh

Misalkan untuk daftar bilangan bulat, hanya bilangan yang bertambah yang harus dipertahankan. dibuat khusus Gatherer seharusnya penuh keadaan Dan berurutan untuk mencapainya.
penuh keadaan – karena hanya bilangan bulat yang lebih besar dari bilangan sebelumnya yang harus dipertahankan.
memesan –karena harus menjaga urutan elemen. Jika diolah secara paralel, hasilnya akan seperti itu tidak pasti.

Gatherer<Integer, int[], Integer> INCREASING_ONLY =
            Gatherer.ofSequential( // enfore sequential processing for deterministic processing
                    () -> new int[1], // state - maintain last seen value
                    (state, input, downstream) -> 
                        if (input > state[0]) 
                            state[0] = input; // update current as now last seen
                            downstream.push(input); // emit the element to downstream
                        
                        return true; // continue execution
                    
            );

List.of(1, 3, 2, 5, 4, 6, 8, 7, 9)
    .stream()
    .gather(INCREASING_ONLY)
    .forEach(System.out::println);


Output => 1, 3, 5, 6, 8, 9

Setiap operasi aliran standar dapat dinyatakan sebagai kolektor, akan menjadi latihan yang baik untuk mencoba menerapkannya sebagai kebiasaan Gatherer. Misalnya,

• map — Tanpa kewarganegaraan satu-ke-satu Kolektor mengubah elemen.
• filter — tanpa kewarganegaraan Kolektor hanya mengeluarkan emisi jika kondisinya terpenuhi true
• flatMap — Satu-ke-banyak tanpa kewarganegaraan Kolektor mengubah dan memancarkan semua elemen.
• distinct — penuh keadaan Kolektor melacak elemen yang dilihatnya.

sebagai kesimpulan

pengumpul aliran Java 24 menandai evolusi penting Antarmuka media streamingmemberdayakan pengembang Operasi perantara yang dapat disesuaikan Dulunya berada di luar jangkauan. Dengan menjembatani kesenjangan antara jalur pipa yang kaku dan transformasi ekspresif, Pengumpul membuka kemungkinan baru untuk logika aliran yang bersih, efisien, dan dapat digunakan kembali. meskipun Kolektor bawaan Meliputi pola umum, Penerapan khusus harus diperlakukan dengan hati-hati untuk menjaga keterbacaan dan kinerja. Bagi para insinyur dan arsitek, menguasai Pengumpul berarti kontrol yang lebih baik atas aliran data dan perilaku saluran pipa—keterampilan penting seiring dengan kemajuan Java menuju paradigma fungsional dan deklaratif.

Referensi dan bacaan lebih lanjut