JavaRush /Java Blog /Random-ID /Aliran API

Level 36

28 Februari 2021
53 views
0 comments

Aliran API

Apa itu API Aliran?

Stream API adalah cara baru untuk bekerja dengan struktur data dalam gaya fungsional. Stream API (deskripsi cara di mana satu program komputer dapat berkomunikasi dengan program lain), pada intinya, adalah aliran data. Istilah "thread" sendiri cukup kabur dalam pemrograman pada umumnya dan Java pada khususnya.

Dengan munculnya Java 8, Stream API memungkinkan pemrogram untuk menulis lebih singkat apa yang sebelumnya memerlukan banyak baris kode, yaitu untuk menyederhanakan pekerjaan dengan kumpulan data, khususnya, untuk menyederhanakan pemfilteran, pengurutan, dan operasi manipulasi data lainnya. Jika Anda tidak memiliki operasi perantara, Anda dapat dan harus sering melakukannya tanpa aliran, jika tidak, kodenya akan lebih rumit daripada tanpa aliran.

Di mana tepatnya saya harus memulai? Dari pembuatan instance Stream, yang didasarkan pada koleksi, array, atau metode yang kita perlukan dan dari mana data akan diambil:

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 disebutkan di atas, Stream API memungkinkan Anda mengurangi jumlah baris kode. 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 thread:

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);
	}

Kemungkinan cara untuk membuat Aliran:

Aliran kosong:Stream.empty()
Streaming dari Daftar:list.stream()
Streaming dari Peta:map.entrySet().stream()
Streaming dari array:Arrays.stream(array)
Streaming dari elemen yang ditentukan:Stream.of("1", "2", "3")

Lebih lanjut, ada yang namanya operator (pada dasarnya adalah metode kelas Stream).Operator dapat dibagi menjadi dua kelompok:

Menengah (juga disebut "malas") - memproses elemen masuk dan mengembalikan aliran. Terdapat banyak operator perantara dalam rantai pemrosesan elemen.
Terminal (“terminal”, juga disebut “bersemangat”) - memproses elemen dan menghentikan aliran, sehingga hanya 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 terjadi di sini:

1 - buat daftar list;
2-11 - isi dengan data uji;
12 - membuat objek Stream;
13 - metode filter(filter) - operator perantara, xdisamakan dengan satu elemen koleksi untuk enumerasi (seperti for each) dan setelah -> kami menunjukkan bagaimana koleksi kami disaring dan karena ini adalah operator perantara, koleksi yang difilter berlanjut ke metode, forEachyang pada gilirannya merupakan analog enumerasi terminal (final) for each(Ekspresi System.out::printlnkependekan dari:, x-> System.out.println(x))yang pada gilirannya menelusuri semua elemen koleksi yang diteruskan ke sana dan menampilkannya)

Poin penting:

Pemrosesan tidak akan dimulai sampai operator terminal dipanggil. list.stream().filter(s -> s > 5)(tidak akan mengambil satu elemen pun dari daftar);
Sebuah instance dari aliran tidak dapat digunakan lebih dari sekali =( ;

Oleh karena itu, setiap kali ada yang baru:

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

Ada banyak operator perantara yang dipanggil dalam satu aliran, sedangkan operator terminal hanya satu:

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

Selanjutnya, mari kita lihat beberapa operator perantara:

filter(Predicate predicate)memfilter aliran, hanya meneruskan elemen-elemen yang lolos kondisi (Predikat adalah antarmuka fungsional bawaan yang ditambahkan ke paket di Java SE 8. java.util.functionMemeriksa nilai untuk “ true ” dan “ false ”);
map(Function mapper)memungkinkan untuk membuat fungsi yang dengannya kita akan mengubah setiap elemen dan melewatinya lebih jauh (Antarmuka fungsional Function<T,R>mewakili fungsi transisi dari objek bertipe T ke objek bertipe R)
flatMap(Function<T, Stream<R>> mapper)- seperti halnya dengan map, mereka digunakan untuk mengkonversi ke aliran primitif.

Saat bekerja, misalnya, dengan array aliran (array, daftar, dan sebagainya), ia mengubahnya menjadi satu aliran (array, daftar, dan seterusnya [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);

Sementara mapitu diubah menjadi daftar utas (lebih tepatnya <Stream>utas) [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);

Perbedaan lainnya dibandingkan dengan map, Anda dapat mengonversi satu elemen menjadi nol, satu, atau banyak elemen lainnya. Untuk mengubah satu elemen menjadi elemen nol, Anda perlu return null, atau aliran kosong. Untuk mengonversi ke satu elemen, Anda perlu mengembalikan aliran dari satu elemen, misalnya melalui Stream.of(x). Untuk mengembalikan beberapa elemen, Anda dapat membuat aliran dengan elemen tersebut dengan cara apa pun. Metode flatMap yang sama, tetapi untuk Double, Integer dan Long:

flatMapToDouble(Pemeta fungsi)
flatMapToInt(Pemeta fungsi)
flatMapToLong(Pemeta fungsi)

Dan contoh lain 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 dari 0 (inklusif) hingga x (tidak inklusif) ke aliran;

peta:

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

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

lewati(panjang n) – lewati n elemen:

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

diurutkan()
diurutkan(Komparator komparator) – mengurutkan aliran (menyortir seperti TreeMap):
```
stream.sorted().forEach(x -> System.out.println(x));
```
berbeda() — memeriksa aliran untuk keunikan elemen (menghilangkan pengulangan elemen);
dropWhile(Predikat predikat) - melewatkan elemen yang memenuhi kondisi (muncul di java 9, Antarmuka fungsional Predicate<T> memeriksa apakah kondisi tertentu terpenuhi. Jika terpenuhi, maka true dikembalikan. Ekspresi lambda mengambil objek ketik 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 Konsumen) – analog dari untuk masing-masing (Konsumen<T> melakukan beberapa tindakan pada objek bertipe T, tanpa mengembalikan apa pun);
count() – mengembalikan jumlah elemen aliran:

System.out.println(stream.count());
mengumpulkan(Kolektor kolektor) – metode mengumpulkan semua elemen ke dalam daftar, kumpulan atau koleksi lainnya, mengelompokkan elemen menurut beberapa kriteria, menggabungkan semuanya menjadi sebuah string, dll.:
```
List<String> list = Stream.of(“One”, “Two”, “Three”).collect(Collectors.toList());
```
collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)— sama seperti , collect(collector)hanya parameternya yang dipecah untuk kenyamanan ( suppliermemasok objek baru (wadah), misalnya new ArrayList(), accumulatormenambahkan elemen ke wadah, combinermenggabungkan bagian-bagian aliran menjadi satu);
kurangi(T identitas, Akumulator BinerOperator) - mengubah semua elemen aliran menjadi satu objek (hitung jumlah semua elemen, atau temukan elemen minimum), pertama-tama objek identitydan elemen pertama aliran diambil, fungsinya diterapkan accumulatordan identityhasilnya menjadi. Kemudian semuanya berlanjut untuk elemen lainnya.
```
int sum = Stream.of(1, 2, 3, 4, 5).reduce(10, (acc, x) -> acc + x);// = 25
```
reduce(BinaryOperator accumulator)— metode yang sama seperti di atas tetapi metode awal tidak ada identity, ini adalah elemen pertama dari aliran

Optional min(Comparator comparator)
Opsional max(Comparator comparator) mencari elemen minimum/maksimum berdasarkan komparator yang diteruskan;
findFirst()– mengeluarkan elemen pertama dari aliran:
```
Stream.of(1, 2, 3, 4, 9).findFirst();
```
allMatch(Predicate predicate)— mengembalikan nilai benar jika semua elemen aliran memenuhi kondisi. Jika ada elemen yang ditemui yang hasil pemanggilan fungsi predikatnya adalah false , maka operator berhenti memindai elemen tersebut dan mengembalikan false :
```
Stream.of(1, 2, 3, 4, 9).allMatch(x -> x <= 7);//false
```
anyMatch(Predicate predicate)— akan mengembalikan nilai benar jika setidaknya satu elemen aliran memenuhi kondisi predicate:
```
Stream.of(1, 2, 3, 4, 9).anyMatch(x -> x >= 7);//true
```
noneMatch(Predicate predicate)— akan mengembalikan nilai benar jika, setelah melewati semua elemen aliran, tidak ada satupun yang memenuhi kondisi predicate:
```
Stream.of(1, 2, 3, 4, 9).noneMatch(x -> x >= 7);//false
```

Dan akhirnya saya ingin melihat beberapa metode Collectors:

toList()— mengumpulkan elemen menjadi List:

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

toSet()— mengumpulkan elemen menjadi satu set:

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

counting()— Menghitung jumlah elemen:

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

joining()
joining(CharSequence delimiter)

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)— mengumpulkan elemen menjadi satu baris. Selain itu, Anda dapat menentukan pemisah, serta awalan dan akhiran untuk seluruh urutan:

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)- seorang kolektor yang mengubah objek menjadi int/long/double dan menghitung jumlahnya.

Tautan yang berguna:

PS: jangan malu-malu menghujani kami dengan like ^ : ^

Komentar

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