JavaRush /Blog Jawa /Random-JV /Stream API

tingkat

28 February 2021
42 views
0 comments

Stream API

Apa Stream API?

Stream API minangka cara anyar kanggo nggarap struktur data kanthi gaya fungsional. A Stream API (deskripsi babagan cara siji program komputer bisa komunikasi karo program liyane), ing inti, aliran data. Istilah "thread" dhewe cukup samar ing pemrograman umume lan khususe ing Jawa.

Kanthi tekane Java 8, Stream API ngidini para programer nulis luwih ringkes babagan sing sadurunge njupuk akeh baris kode, yaiku, kanggo nyederhanakake karya karo set data, utamane, kanggo nyederhanakake nyaring, ngurutake lan operasi manipulasi data liyane. Yen sampeyan ora duwe operasi penengah, sampeyan bisa lan kudu kerep nindakake tanpa stream, yen kode bakal luwih rumit tinimbang tanpa stream.

Where, persis, aku kudu miwiti? Saka nggawe conto Stream, sing adhedhasar koleksi, larik utawa metode sing dibutuhake lan saka ngendi data kasebut bakal dijupuk:

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

Kaya kasebut ing ndhuwur, Stream API ngidini sampeyan nyuda jumlah baris kode. Conto karo stream:

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

Tuladha tanpa utas:

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 sing bisa ditindakake kanggo nggawe Stream:

Aliran kosong:Stream.empty()
Stream saka Daftar:list.stream()
Stream saka Peta:map.entrySet().stream()
Stream saka array:Arrays.stream(array)
Stream saka unsur sing ditemtokake:Stream.of("1", "2", "3")

Kajaba iku, ana operator (utamane metode kelas Stream). Operator bisa dipérang dadi rong klompok:

Penengah (uga disebut "malas") - ngolah unsur sing mlebu lan ngasilake stream kasebut. Bisa uga ana akeh operator penengah ing rantai pangolahan unsur.
Terminal ("terminal", uga disebut "semangat") - ngolah unsur lan mungkasi aliran, saengga mung ana siji operator terminal ing ranté kasebut.

Tuladha:

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 sing kedadeyan ing kene:

1 - nggawe dhaptar list;
2-11 - isi karo data test;
12 - nggawe obyek Stream;
13 - metode filter(filter) - operator penengah, xpadha karo siji unsur koleksi kanggo enumerasi (kaya karo for each) lan sawise -> kita nuduhake carane koleksi kita disaring lan amarga iki operator penengah, koleksi disaring dadi luwih menyang cara , forEachsing dadi analog terminal (final) saka enumerasi for each(Ekspresi System.out::printlnsingkatan kanggo:, x-> System.out.println(x))sing banjur ngliwati kabeh unsur koleksi sing diterusake lan nampilake)

Titik penting:

Pangolahan ora bakal diwiwiti nganti operator terminal diarani. list.stream().filter(s -> s > 5)(ora bakal njupuk unsur siji saka dhaftar);
Kayata stream ora bisa digunakake luwih saka sepisan =(;

Mulane, saben-saben anyar:

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

Bisa uga ana akeh operator perantara sing diarani ing siji stream, dene mung ana siji 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));

Sabanjure, ayo goleki sawetara operator penengah:

filter(Predicate predicate)nyaring stream, mung liwat unsur sing pass kondisi (Predicate punika antarmuka fungsi dibangun ing ditambahake menyang paket ing Jawa SE 8. java.util.functionPriksa nilai kanggo " bener "lan " palsu ");
map(Function mapper)ndadekake iku bisa kanggo nggawe fungsi karo kang kita bakal ngganti saben unsur lan skip iku luwih (Antarmuka fungsi Function<T,R>nggantosi fungsi transisi saka obyek saka jinis T kanggo obyek saka jinis R)
flatMap(Function<T, Stream<R>> mapper)- kaya ing kasus karo map, padha digunakake kanggo Ngonversi menyang stream primitif.

Nalika nggarap, umpamane, kanthi macem-macem aliran (susun, dhaptar, lan liya-liyane), ngowahi dadi siji aliran (susun, dhaptar, lan sapiturute [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);

Nalika mapdiowahi dadi dhaptar utas (luwih tepate <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);

prabédan liyane dibandhingake karo map, sampeyan bisa ngowahi siji unsur kanggo nul, siji utawa akeh liyane. Kanggo ngowahi siji unsur menyang unsur nul, sampeyan kudu bali null, utawa stream kosong. Kanggo ngowahi menyang siji unsur, sampeyan kudu bali stream saka siji unsur, contone, liwat Stream.of(x). Kanggo ngasilake sawetara unsur, sampeyan bisa nggawe stream karo unsur kasebut kanthi cara apa wae. Cara flatMap sing padha, nanging kanggo Double, Integer lan Long:

flatMapToDouble(Fungsi mapper)
flatMapToInt(Fungsi mapper)
flatMapToLong(Function mapper)

Lan conto liyane kanggo mbandhingake, flatMap:

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

IntStream.range (0,x) - output unsur saka 0 (kalebu) kanggo x (ora klebu) kanggo stream;

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) - mbatesi aliran kanthi jumlah unsur:
```
stream.limit(5).forEach(x -> System.out.println(x));
```

skip(long n) - skip n elemen:

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

diurutake ()
sorted (Comparator comparator) - ngurutake stream (ngurutake kaya TreeMap):
```
stream.sorted().forEach(x -> System.out.println(x));
```
distinct () - mriksa stream kanggo uniqueness saka unsur (mbusak repetitions saka unsur);
dropWhile(predikat predikat) - skip unsur sing gawe marem kondisi (katon ing java 9, antarmuka fungsi Predikat<T> mriksa apa sawetara kondisi ketemu. Yen ketemu, banjur bener bali. Ekspresi lambda njupuk obyek saka jinis T minangka parameter:
```
Predicate<Integer> isPositive = x -> x > 0;
       System.out.println(isPositive.test(3)); // true
       System.out.println(isPositive.test(-9)); // false
```

Operator terminal:

forEach(Consumer action) - analog kanggo saben (Consumer<T> nindakake sawetara tumindak ing obyek saka jinis T tanpa bali apa-apa);
count () - ngasilake jumlah unsur stream:

System.out.println(stream.count());
ngumpulake (kolektor kolektor) - cara nglumpukake kabeh unsur menyang dhaptar, set utawa koleksi liyane, nglumpukake unsur miturut sawetara kritéria, nggabungake kabeh dadi senar, lsp.
```
List<String> list = Stream.of(“One”, “Two”, “Three”).collect(Collectors.toList());
```
collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)— padha , collect(collector)mung paramèter sing bejat mudhun kanggo penak ( supplierPenyetor obyek anyar (kontainer), contone new ArrayList(), accumulatornambah unsur kanggo wadhah, combinernggabungke bagéan saka stream bebarengan);
nyuda (identitas T, akumulator BinaryOperator) - ngowahi kabeh unsur stream dadi siji obyek (ngetung jumlah kabeh unsur, utawa golek unsur minimal), pisanan njupuk obyek identitylan unsur pisanan stream, aplikasi fungsi accumulatorlan identitydadi asile. Banjur kabeh terus kanggo unsur sing isih ana.
```
int sum = Stream.of(1, 2, 3, 4, 5).reduce(10, (acc, x) -> acc + x);// = 25
```
reduce(BinaryOperator accumulator)- cara sing padha ing ndhuwur nanging sing wiwitan ora ana identity, iki minangka unsur pisanan saka aliran kasebut

Optional min(Comparator comparator)
Opsional max(Comparator comparator) nggoleki unsur minimal/maksimum adhedhasar komparator liwati;
findFirst()- narik metu unsur pisanan saka stream:
```
Stream.of(1, 2, 3, 4, 9).findFirst();
```
allMatch(Predicate predicate)- ngasilake bener yen kabeh unsur stream marem kondisi. Yen ana unsur sing ditemokake minangka asil nelpon fungsi predikat salah , operator mandheg mindhai unsur kasebut lan ngasilake palsu :
```
Stream.of(1, 2, 3, 4, 9).allMatch(x -> x <= 7);//false
```
anyMatch(Predicate predicate)- bakal bali bener yen paling ora siji unsur stream marem kondisi predicate:
```
Stream.of(1, 2, 3, 4, 9).anyMatch(x -> x >= 7);//true
```
noneMatch(Predicate predicate)- bakal bali bener yen, sawise ngliwati kabeh unsur stream, ora ana sing marem kondisi predicate:
```
Stream.of(1, 2, 3, 4, 9).noneMatch(x -> x >= 7);//false
```

Lan pungkasane aku pengin ndeleng sawetara cara Collectors:

toList()- ngumpulake unsur dadi List:

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

toSet()- ngumpulake unsur menyang set:

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

counting()- Ngitung jumlah unsur:

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

joining()
joining(CharSequence delimiter)

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)- ngumpulake unsur dadi siji baris. Kajaba iku, sampeyan bisa nemtokake pemisah, uga prefiks lan sufiks kanggo kabeh 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)- kolektor sing ngowahi obyek kanggo int / dawa / pindho lan ngetung jumlah.

Pranala migunani:

PS: ojo isin nyiram kita karo likes ^ : ^

Komentar

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