Menganalisis contoh operasi terminal dalam Java Stream API

1. Operasi pemprosesan data saluran paip Java Stream

Dalam artikel yang saya tulis sebelum ini, saya memperkenalkan kepada anda bahawa aliran saluran paip Java Stream digunakan Java API untuk memudahkan pemprosesan elemen kelas koleksi. Proses penggunaan terbahagi kepada tiga peringkat. Sebelum memulakan artikel ini, saya rasa saya masih perlu memperkenalkan tiga peringkat ini kepada beberapa rakan baru, seperti yang ditunjukkan dalam gambar:

• Peringkat pertama (dalam gambar Biru): Tukar koleksi, tatasusunan atau fail teks baris ke dalam aliran saluran paip java Stream

• Peringkat kedua (bahagian garis putus-putus dalam rajah): Penstriman saluran paip operasi pemprosesan data, pemprosesan saluran paip setiap elemen dalam . Elemen keluaran dari paip sebelumnya berfungsi sebagai elemen input untuk paip seterusnya.

• Peringkat ketiga (hijau dalam gambar): operasi pemprosesan hasil aliran saluran paip, yang merupakan kandungan teras artikel ini.

Sebelum mula belajar, masih perlu menyemak contoh yang kami beritahu anda sebelum ini:

List<String> nameStrs = Arrays.asList("Monkey", "Lion", "Giraffe","Lemur");
List<String> list = nameStrs.stream()
        .filter(s -> s.startsWith("L"))
        .map(String::toUpperCase)
        .sorted()
        .collect(toList());
System.out.println(list);

Mula-mula gunakan kaedah stream() untuk menukar rentetan Senarai Untuk aliran paip Aliran

dan kemudian lakukan operasi pemprosesan data saluran paip, mula-mula gunakan fungsi penapis untuk menapis semua rentetan bermula dengan huruf besar L, kemudian tukar rentetan dalam saluran paip kepada huruf besar kepada Huruf Besar, dan kemudian panggil kaedah yang diisih untuk menyusun. Penggunaan API ini telah diperkenalkan dalam artikel sebelumnya artikel ini. Ungkapan Lambda dan rujukan fungsi juga digunakan.

Akhir sekali, gunakan fungsi kumpul untuk pemprosesan hasil dan tukar aliran saluran paip java Stream menjadi Senarai. Output akhir senarai ialah: [LEMUR, LION]

Jika anda tidak menggunakan aliran saluran paip java Stream, fikirkan tentang berapa banyak baris kod yang anda perlukan untuk melengkapkan fungsi di atas? Kembali ke topik, artikel ini akan memperkenalkan anda kepada peringkat ketiga: apakah operasi yang boleh dilakukan pada hasil pemprosesan aliran saluran paip? Mari mulakan!

2. ForEach dan ForEachOrdered

Jika kita hanya mahu mencetak hasil pemprosesan saluran paip Strim dan bukannya melakukan penukaran jenis, kita boleh menggunakan kaedah forEach() atau kaedah forEachOrded() . Fungsi

Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion")
        .parallel()
        .forEach(System.out::println);
Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion")
        .parallel()
        .forEachOrdered(System.out::println);

selari() menunjukkan pemprosesan selari elemen dalam saluran paip dan bukannya pemprosesan bersiri, yang menghasilkan pemprosesan yang lebih pantas. Walau bagaimanapun, ini boleh menyebabkan elemen kemudian dalam aliran paip diproses terlebih dahulu, dan elemen sebelumnya diproses kemudian, iaitu susunan elemen tidak boleh dijamin

forEachOrdered boleh difahami daripada nama, walaupun mungkin dalam susunan pemprosesan data Tidak ada jaminan, tetapi kaedah forEachOrded boleh memastikan bahawa susunan unsur-unsur dikeluarkan adalah konsisten dengan susunan unsur-unsur memasuki aliran saluran paip. Iaitu, ia kelihatan seperti berikut (kaedah untukSetiap tidak dapat menjamin pesanan ini):

Monyet
Singa
Zirafah
Lemur
Singa

3. Pengumpulan elemen mengumpul

Penggunaan java Stream yang paling biasa ialah: pertama, tukar kelas koleksi kepada aliran saluran paip, kedua, proses data aliran saluran paip, dan ketiga, tukar aliran saluran paip memproses hasil ke dalam kelas koleksi. Kemudian kaedah collect() memberikan kita fungsi untuk menukar hasil pemprosesan aliran saluran paip kepada kelas koleksi.

3.1. Kumpul sebagai Set

Kumpulkan hasil pemprosesan Strim melalui kaedah Collectors.toSet() dan kumpulkan semua elemen ke dalam koleksi Set.

Set<String> collectToSet = Stream.of(
   "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
) 
.collect(Collectors.toSet());
//最终collectToSet 中的元素是:[Monkey, Lion, Giraffe, Lemur]，注意Set会去重。

3.2 Kumpulkan ke dalam Senarai

Begitu juga, elemen boleh dikumpulkan ke dalam List menggunakan toList() pengumpul.

List<String> collectToList = Stream.of(
   "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
).collect(Collectors.toList());

// 最终collectToList中的元素是: [Monkey, Lion, Giraffe, Lemur, Lion]

3.3 Kaedah pengumpulan universal

Kaedah pengumpulan elemen yang diperkenalkan di atas semuanya khusus. Contohnya, gunakan Collectors.toSet() untuk mengumpul koleksi jenis Set gunakan Collectors.toList() untuk mengumpul koleksi jenis Senarai. Jadi, adakah terdapat cara yang lebih umum untuk mengumpul elemen data untuk mengumpul data ke dalam mana-mana subjenis antara muka Koleksi? Oleh itu, berikut ialah cara umum untuk mengumpul elemen Anda boleh mengumpul elemen data ke dalam mana-mana jenis Koleksi: iaitu, dengan menyediakan pembina kepada jenis Koleksi yang diperlukan.

LinkedList<String> collectToCollection = Stream.of(
   "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
).collect(Collectors.toCollection(LinkedList::new));
//最终collectToCollection中的元素是: [Monkey, Lion, Giraffe, Lemur, Lion]

Nota: LinkedList::new digunakan dalam kod, yang sebenarnya memanggil pembina LinkedList untuk mengumpul elemen ke dalam Senarai Berpaut. Sudah tentu, anda juga boleh menggunakan item seperti LinkedHashSet::new dan PriorityQueue::new untuk mengumpul elemen data ke dalam jenis koleksi lain, yang lebih serba boleh.

3.4. Kumpul Array

Kumpulkan hasil pemprosesan Strim melalui kaedah toArray(String[]::new) dan kumpulkan semua elemen ke dalam tatasusunan rentetan.

String[] toArray = Stream.of(
   "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
) .toArray(String[]::new);
//最终toArray字符串数组中的元素是: [Monkey, Lion, Giraffe, Lemur, Lion]

3.5 Dikumpul ke dalam Peta

Gunakan kaedah Collectors.toMap() untuk mengumpul elemen data ke dalam Peta, tetapi terdapat masalah: iaitu, sama ada elemen dalam saluran paip digunakan sebagai kunci atau sebagai nilai. Kami menggunakan kaedah Function.identity(), yang hanya mengembalikan "t -> t" (input ialah ungkapan lambda output). Selain itu, gunakan fungsi pemprosesan aliran saluran paip distinct() untuk memastikan keunikan nilai kunci Peta.

Map<String, Integer> toMap = Stream.of(
    "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
)
.distinct()
.collect(Collectors.toMap(
       Function.identity(),   //元素输入就是输出，作为key
       s -> (int) s.chars().distinct().count()// 输入元素的不同的字母个数，作为value
));
// 最终toMap的结果是: {Monkey=6, Lion=4, Lemur=5, Giraffe=6}

3.6. GroupingBy

Collectors.groupingBy digunakan untuk melaksanakan pengumpulan kumpulan elemen Kod berikut menunjukkan cara mengumpul elemen data yang berbeza ke dalam Senarai yang berbeza berdasarkan huruf pertama dan merangkumnya. untuk Peta.

Map<Character, List<String>> groupingByList =  Stream.of(
    "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
)
.collect(Collectors.groupingBy(
       s -> s.charAt(0) ,  //根据元素首字母分组，相同的在一组
       // counting()        // 加上这一行代码可以实现分组统计
));
// 最终groupingByList内的元素: {G=[Giraffe], L=[Lion, Lemur, Lion], M=[Monkey]}
//如果加上counting() ，结果是:  {G=1, L=3, M=1}

这是该过程的说明：groupingBy第一个参数作为分组条件，第二个参数是子收集器。

四、其他常用方法

boolean containsTwo = IntStream.of(1, 2, 3).anyMatch(i -> i == 2);
// 判断管道中是否包含2，结果是: true
long nrOfAnimals = Stream.of(
    "Monkey", "Lion", "Giraffe", "Lemur"
).count();
// 管道中元素数据总计结果nrOfAnimals: 4
int sum = IntStream.of(1, 2, 3).sum();
// 管道中元素数据累加结果sum: 6
OptionalDouble average = IntStream.of(1, 2, 3).average();
//管道中元素数据平均值average: OptionalDouble[2.0]
int max = IntStream.of(1, 2, 3).max().orElse(0);
//管道中元素数据最大值max: 3
IntSummaryStatistics statistics = IntStream.of(1, 2, 3).summaryStatistics();
// 全面的统计结果statistics: IntSummaryStatistics{count=3, sum=6, min=1, average=2.000000, max=3}

Atas ialah kandungan terperinci Menganalisis contoh operasi terminal dalam Java Stream API. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!