JavaRush /Blog Java /Random-MS /API Strim

Tahap

28 February 2021
37 views
0 comments

API Strim

Apakah itu Stream API?

API Strim ialah cara baharu untuk bekerja dengan struktur data dalam gaya berfungsi. API Strim (penerangan tentang cara satu atur cara komputer boleh berkomunikasi dengan atur cara lain), pada terasnya, aliran data. Istilah "benang" itu sendiri agak kabur dalam pengaturcaraan secara umum dan di Jawa khususnya.

Dengan kemunculan Java 8, Stream API membenarkan pengaturcara untuk menulis dengan lebih ringkas apa yang sebelum ini mengambil banyak baris kod, iaitu, untuk memudahkan kerja dengan set data, khususnya, untuk memudahkan operasi penapisan, pengisihan dan manipulasi data lain. Jika anda tidak mempunyai operasi perantaraan, anda boleh dan harus selalu melakukannya tanpa strim, jika tidak, kod akan menjadi lebih rumit daripada tanpa strim.

Di mana, sebenarnya, saya harus bermula? Daripada penciptaan contoh Strim, yang berdasarkan pengumpulan, tatasusunan atau kaedah yang kami perlukan dan dari mana data akan diambil dengan sewajarnya:

List<String> list = new ArrayList<String>();
       list.add("One");
       list.add("Two");
       list.add("Three");
       list.add("Four");
       list.add("Five");
       list.add("Six");
       list.add("Seven");
       list.add("Eight");
       list.add("Nine");
       list.add("Ten");
       Stream stream = list.stream();

Seperti yang dinyatakan di atas, API Strim membolehkan anda mengurangkan bilangan baris kod. Contoh dengan aliran:

IntStream.of(50, 60, 70, 80, 90, 100, 110, 120).filter(x -> x < 90).map(x -> x + 10)
.limit(3).forEach(System.out::print);

Contoh tanpa benang:

int[] arr = {50, 60, 70, 80, 90, 100, 110, 120
	int count = 0;
	for (int x : arr) {
	    if (x >= 90) continue;
	    x += 10;
	    count++;
	    if (count > 3) break;
	    System.out.print(x);
	}

Cara yang mungkin untuk membuat Strim:

Strim kosong:Stream.empty()
Strim daripada Senarai:list.stream()
Strim daripada Peta:map.entrySet().stream()
Strim daripada tatasusunan:Arrays.stream(array)
Strim daripada elemen yang ditentukan:Stream.of("1", "2", "3")

Selanjutnya, terdapat perkara seperti operator (pada asasnya kaedah kelas Stream). Operator boleh dibahagikan kepada dua kumpulan:

Pertengahan (juga dipanggil "malas") - memproses elemen masuk dan mengembalikan strim. Terdapat banyak operator perantaraan dalam rantaian pemprosesan elemen.
Terminal ("terminal", juga dipanggil "semangat") - memproses elemen dan menamatkan aliran, jadi hanya boleh ada satu operator terminal dalam rantai.

Contoh:

1.List<String> list = new ArrayList<String>();
2.list.add("One");
…
11.list.add("Ten");
12.Stream stream = list.stream();
13.stream.filter(x-> x.toString().length() == 3).forEach(System.out::println);

Apa yang berlaku di sini:

1 - buat senarai list;
2-11 - isi dengan data ujian;
12 - cipta objek Stream;
13 - kaedah filter(penapis) - pengendali perantaraan, xbersamaan dengan satu elemen koleksi untuk penghitungan (seperti dengan for each) dan selepas -> kami menunjukkan cara koleksi kami ditapis dan kerana ini adalah pengendali perantaraan, koleksi yang ditapis pergi lebih jauh ke kaedah , forEachyang seterusnya adalah terminal (akhir) analog penghitungan for each(Ungkapan System.out::printlnsingkatan untuk:, x-> System.out.println(x))yang seterusnya melalui semua elemen koleksi yang dihantar kepadanya dan memaparkannya)

Perkara penting:

Pemprosesan tidak akan bermula sehingga operator terminal dipanggil. list.stream().filter(s -> s > 5)(tidak akan mengambil satu elemen daripada senarai);
Contoh strim tidak boleh digunakan lebih daripada sekali =( ;

Oleh itu, setiap kali ia baharu:

list.stream().filter(x-> x.toString().length() == 3).forEach(System.out::println);
list.stream().forEach(x -> System.out.println(x));

Terdapat banyak pengendali perantaraan yang dipanggil pada satu aliran, sementara hanya terdapat satu operator terminal:

stream.filter(x-> x.toString().length() == 3).map(x -> x + " - the length of the letters is three").forEach(x -> System.out.println(x));

Seterusnya, mari kita lihat beberapa pengendali perantaraan:

filter(Predicate predicate)menapis strim, hanya melepasi elemen yang melepasi syarat (Predikat ialah antara muka berfungsi terbina dalam yang ditambahkan pada pakej dalam Java SE 8. java.util.functionMenyemak nilai untuk " benar " dan " palsu ");
map(Function mapper)memungkinkan untuk mencipta fungsi yang mana kita akan menukar setiap elemen dan melangkaunya lagi (Antara muka berfungsi Function<T,R>mewakili fungsi peralihan daripada objek jenis T kepada objek jenis R)
flatMap(Function<T, Stream<R>> mapper)- seperti dalam kes dengan map, ia digunakan untuk menukar kepada aliran primitif.

Apabila bekerja, sebagai contoh, dengan tatasusunan strim (susunan, senarai, dan sebagainya), ia menukarnya kepada satu aliran (susunan, senarai, dan sebagainya [stream1,stream2,stream3,stream4] => stream:

String[] array = {"Java", "Ruuuuussshhh"};
Stream<String> streamOfArray = Arrays.stream(array);
streamOfArray.map(s->s.split("")) //Convert the word to an array of letters
        .flatMap(Arrays::stream).distinct() //aligns each generated thread into a single thread
        .collect(Collectors.toList()).forEach(System.out::println);

Walaupun mapia bertukar kepada senarai benang (lebih tepat lagi <Stream>benang) [stream1,stream2,stream3,stream4] =>Stream.of(stream1,stream2,stream3,stream4):

String[] array = {"Java", "Ruuuuussshhh"};
Stream<String> streamOfArray = Arrays.stream(array);
streamOfArray.map(s->s.split("")) //Convert the word to an array of letters
        .map(Arrays::stream).distinct() //Make the array into a separate thread
        .collect(Collectors.toList()).forEach(System.out::println);

Satu lagi perbezaan berbanding dengan map, anda boleh menukar satu elemen kepada sifar, satu atau banyak lagi. Untuk menukar satu elemen kepada sifar elemen, anda perlu return null, atau strim kosong. Untuk menukar kepada satu elemen, anda perlu mengembalikan aliran daripada satu elemen, contohnya, melalui Stream.of(x). Untuk mengembalikan beberapa elemen, anda boleh membuat strim dengan elemen ini dengan apa-apa cara. Kaedah flatMap yang sama, tetapi untuk Double, Integer dan Long:

flatMapToDouble(Fungsi pemeta)
flatMapToInt(Fungsi pemeta)
flatMapToLong(Fungsi pemeta)

Dan satu lagi contoh untuk perbandingan, flatMap:

Stream.of(2, 3, 0, 1, 3)
        .flatMapToInt(x -> IntStream.range(0, x))
        .forEach(System.out::print);// 010120012

IntStream.range(0,x) – mengeluarkan elemen daripada 0 (inklusif) kepada x (tidak termasuk) kepada strim;

peta:

Stream.of(2, 3, 0, 1, 3)
        .map(x -> IntStream.range(0, x))
        .forEach(System.out::print);//list of streams (streams);

had(long maxSize) – mengehadkan aliran dengan bilangan elemen:
```
stream.limit(5).forEach(x -> System.out.println(x));
```

langkau(long n) – langkau n elemen:

stream.skip(3).forEach(x -> System.out.println(x));

disusun()
sorted(Comparator comparator) - mengisih aliran (isih seperti TreeMap):
```
stream.sorted().forEach(x -> System.out.println(x));
```
distinct() — menyemak strim untuk keunikan elemen (mengeluarkan pengulangan elemen);
dropWhile(Predicate predicate) - melangkau elemen yang memenuhi syarat (muncul dalam java 9, Antara muka berfungsi Predicate<T> menyemak sama ada beberapa syarat dipenuhi. Jika ia dipenuhi, maka benar dikembalikan. Ungkapan lambda mengambil objek jenis T sebagai parameter:
```
Predicate<Integer> isPositive = x -> x > 0;
       System.out.println(isPositive.test(3)); // true
       System.out.println(isPositive.test(-9)); // false
```

Operator terminal:

forEach(Tindakan pengguna) – analog dengan setiap (Pengguna<T> melakukan beberapa tindakan pada objek jenis T tanpa mengembalikan apa-apa);
count() – mengembalikan bilangan elemen aliran:

System.out.println(stream.count());
collect(Collector collector) – kaedah mengumpul semua elemen ke dalam senarai, set atau koleksi lain, kumpulan elemen mengikut beberapa kriteria, menggabungkan semuanya menjadi rentetan, dsb.:
```
List<String> list = Stream.of(“One”, “Two”, “Three”).collect(Collectors.toList());
```
collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)— sama seperti , collect(collector)hanya parameter dipecahkan untuk kemudahan ( suppliermembekalkan objek baharu (bekas), contohnya new ArrayList(), accumulatormenambah elemen pada bekas, combinermenggabungkan bahagian aliran bersama-sama);
reduce(T identiti, BinaryOperator accumulator) - menukar semua elemen aliran menjadi satu objek (kira jumlah semua elemen, atau cari elemen minimum), mula-mula ambil objek identitydan elemen pertama aliran, gunakan fungsi accumulatordan identitymenjadi hasilnya. Kemudian semuanya berterusan untuk unsur-unsur yang tinggal.
```
int sum = Stream.of(1, 2, 3, 4, 5).reduce(10, (acc, x) -> acc + x);// = 25
```
reduce(BinaryOperator accumulator)— kaedah yang sama seperti di atas tetapi yang awal tiada identity, ia adalah elemen pertama strim

Optional min(Comparator comparator)
Maks pilihan (Pembanding pembanding) mencari elemen minimum/maksimum berdasarkan pembanding yang diluluskan;
findFirst()– menarik keluar elemen pertama aliran:
```
Stream.of(1, 2, 3, 4, 9).findFirst();
```
allMatch(Predicate predicate)— kembali benar jika semua elemen aliran memenuhi syarat. Jika mana-mana elemen ditemui yang hasil panggilan fungsi predikat adalah palsu , maka pengendali berhenti mengimbas elemen dan mengembalikan palsu :
```
Stream.of(1, 2, 3, 4, 9).allMatch(x -> x <= 7);//false
```
anyMatch(Predicate predicate)— akan kembali benar jika sekurang-kurangnya satu elemen aliran memenuhi syarat predicate:
```
Stream.of(1, 2, 3, 4, 9).anyMatch(x -> x >= 7);//true
```
noneMatch(Predicate predicate)— akan kembali benar jika, setelah melalui semua elemen aliran, tiada seorang pun daripada mereka memenuhi syarat predicate:
```
Stream.of(1, 2, 3, 4, 9).noneMatch(x -> x >= 7);//false
```

Dan akhirnya saya ingin melihat beberapa kaedah Collectors:

toList()- mengumpul elemen ke dalam List:

List<Integer> list = Stream.of(99, 2, 3).collect(Collectors.toList());

toSet()- mengumpul elemen ke dalam satu set:

Set<Integer> set = Stream.of(99, 2, 3).collect(Collectors.toSet());

counting()— Mengira bilangan elemen:

Long count = Stream.of("1", "2", "3", "4").collect(Collectors.counting());

joining()
joining(CharSequence delimiter)

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)- mengumpul elemen ke dalam satu baris. Selain itu, anda boleh menentukan pemisah, serta awalan dan akhiran untuk keseluruhan jujukan:

String a = Stream.of("s", "u" ,"p", "e", "r").collect(Collectors.joining());
       System.out.println(a); // super

       String b = Stream.of("s", "u", "p", "e", "r").collect(Collectors.joining("-"));
       System.out.println(b); // s-u-p-e-r

       String c = Stream.of("s", "u", "p", "e", "r").collect(Collectors.joining(" -> ", "[ ", " ]"));
       System.out.println(c);  // [ s -> u -> p -> e -> r ]

summingInt(ToIntFunction mapper)
summingLong(ToLongFunction mapper)
summingDouble(ToDoubleFunction mapper)- pengumpul yang menukar objek kepada int/panjang/ganda dan mengira jumlahnya.

Pautan berguna:

PS: jangan malu untuk memberi kami suka ^ : ^

Komen

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION