JavaRush /Java Blog /Random-TL /Stream API

Antas

28 February 2021
39 views
0 comments

Stream API

Ano ang Stream API?

Ang Stream API ay isang bagong paraan upang gumana sa mga istruktura ng data sa isang functional na istilo. Ang Stream API (isang paglalarawan ng mga paraan kung saan maaaring makipag-ugnayan ang isang computer program sa isa pang program), sa kaibuturan nito, isang stream ng data. Ang terminong "thread" mismo ay medyo malabo sa programming sa pangkalahatan at sa Java sa partikular.

Sa pagdating ng Java 8, pinahintulutan ng Stream API ang mga programmer na magsulat nang mas maikli kung ano ang dating kinuha ng maraming linya ng code, ibig sabihin, upang pasimplehin ang pagtatrabaho sa mga set ng data, sa partikular, upang gawing simple ang pag-filter, pag-uuri at iba pang mga operasyon sa pagmamanipula ng data. Kung wala kang mga intermediate na operasyon, maaari at dapat mong gawin nang walang stream, kung hindi, ang code ay magiging mas kumplikado kaysa sa walang stream.

Saan, eksakto, dapat akong magsimula? Mula sa paglikha ng isang halimbawa ng Stream, na nakabatay sa koleksyon, array o pamamaraan na kailangan namin at kung saan kukunin ang data nang naaayon:

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

Gaya ng nabanggit sa itaas, pinapayagan ka ng Stream API na bawasan ang bilang ng mga linya ng code. Halimbawa na may 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);

Halimbawa na walang 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);
	}

Mga posibleng paraan para gumawa ng Stream:

Walang laman na stream:Stream.empty()
Stream mula sa Listahan:list.stream()
Stream mula sa Mapa:map.entrySet().stream()
Stream mula sa array:Arrays.stream(array)
Stream mula sa tinukoy na mga elemento:Stream.of("1", "2", "3")

Dagdag pa, mayroong isang bagay tulad ng mga operator (mahalaga sa mga pamamaraan ng klase ng Stream). Ang mga operator ay maaaring nahahati sa dalawang grupo:

Intermediate (tinatawag ding "tamad") - iproseso ang mga papasok na elemento at ibalik ang stream. Maaaring mayroong maraming intermediate operator sa chain processing ng elemento.
Terminal ("terminal", tinatawag ding "sabik") - iproseso ang mga elemento at wakasan ang stream, kaya maaari lamang magkaroon ng isang terminal operator sa chain.

Halimbawa:

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

Anong nangyayari dito:

1 - lumikha ng isang listahan list;
2-11 - punan ito ng data ng pagsubok;
12 - lumikha ng isang bagay Stream;
13 - pamamaraan filter(filter) - intermediate operator, xkatumbas ng isang elemento ng koleksyon para sa enumeration (tulad ng sa for each) at pagkatapos -> ipinapahiwatig namin kung paano sinasala ang aming koleksyon at dahil ito ay isang intermediate operator, ang na-filter na koleksyon ay napupunta pa sa pamamaraan , forEachna kung saan ay terminal (panghuling) analogue ng enumeration for each(Expression System.out::printlnna maikli para sa:, x-> System.out.println(x))na kung saan ay dumadaan sa lahat ng mga elemento ng koleksyon na ipinasa dito at ipinapakita ito)

Mahahalagang puntos:

Hindi magsisimula ang pagpoproseso hanggang sa tawagin ang operator ng terminal. list.stream().filter(s -> s > 5)(hindi kukuha ng isang elemento mula sa listahan);
Ang isang instance ng isang stream ay hindi maaaring gamitin ng higit sa isang beses =( ;

Samakatuwid, sa tuwing bago ito:

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

Maaaring mayroong maraming intermediate operator na tinatawag sa isang stream, habang mayroon lamang isang terminal operator:

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

Susunod, tingnan natin ang ilang intermediate operator:

filter(Predicate predicate)sinasala ang stream, na pumasa lamang sa mga elementong pumasa sa kundisyon (Ang Predicate ay isang built-in na functional na interface na idinagdag sa package sa Java SE 8. java.util.functionSinusuri ang halaga para sa " true " at " false ");
map(Function mapper)ginagawang posible na lumikha ng isang function kung saan babaguhin namin ang bawat elemento at laktawan ito nang higit pa (Ang functional na interface Function<T,R>ay kumakatawan sa function ng paglipat mula sa isang bagay ng uri T sa isang bagay ng uri R)
flatMap(Function<T, Stream<R>> mapper)- tulad ng sa kaso ng map, ginagamit ang mga ito upang mag-convert sa isang primitive stream.

Kapag nagtatrabaho, halimbawa, sa isang hanay ng mga stream (mga array, listahan, at iba pa), kino-convert nito ang mga ito sa isang stream (array, listahan, at iba pa [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);

Habang mapnagko-convert ito sa isang listahan ng mga thread (mas tiyak <Stream>na mga thread) [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);

Ang isa pang pagkakaiba kumpara sa map, maaari mong i-convert ang isang elemento sa zero, isa o marami pang iba. Upang ma-convert ang isang elemento sa zero na elemento, kailangan mong bumalik null, o isang walang laman na stream. Upang mag-convert sa isang elemento, kailangan mong magbalik ng stream mula sa isang elemento, halimbawa, sa pamamagitan ng Stream.of(x). Upang magbalik ng ilang elemento, maaari kang lumikha ng stream na may mga elementong ito sa anumang paraan. Parehong flatMap method, ngunit para sa Double, Integer at Long:

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

At isa pang halimbawa para sa paghahambing, flatMap:

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

IntStream.range(0,x) – naglalabas ng mga elemento mula 0 (inclusive) hanggang x (not inclusive) sa stream;

mapa:

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

limit(long maxSize) – nililimitahan ang stream ng bilang ng mga elemento:
```
stream.limit(5).forEach(x -> System.out.println(x));
```

laktawan(mahabang n) - laktawan ang n elemento:

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

pinagsunod-sunod ()
sorted(Comparator comparator) – inaayos ang stream (pag-uuri tulad ng TreeMap):
```
stream.sorted().forEach(x -> System.out.println(x));
```
distinct() — sinusuri ang stream para sa uniqueness ng mga elemento (tinatanggal ang mga pag-uulit ng mga elemento);
dropWhile(Predicate predicate) - nilalaktawan ang mga elemento na nakakatugon sa kundisyon (lumabas sa java 9, ang Predicate<T> functional interface ay nagsusuri kung ang isang partikular na kundisyon ay natutugunan. Kung ito ay natugunan, ang totoo ay ibinalik. Ang lambda expression ay tumatagal ng isang object ng i-type ang T bilang isang parameter:
```
Predicate<Integer> isPositive = x -> x > 0;
       System.out.println(isPositive.test(3)); // true
       System.out.println(isPositive.test(-9)); // false
```

Mga operator ng terminal:

forEach(Consumer action) – kahalintulad ng para sa bawat isa (Consumer<T> gumaganap ng ilang aksyon sa isang bagay na may uri ng T nang hindi nagbabalik ng anuman);
count() – ibinabalik ang bilang ng mga elemento ng stream:

System.out.println(stream.count());
collect(Collector collector) – kinokolekta ng pamamaraan ang lahat ng elemento sa isang listahan, set o iba pang koleksyon, pinapangkat ang mga elemento ayon sa ilang criterion, pinagsasama ang lahat sa isang string, atbp.:
```
List<String> list = Stream.of(“One”, “Two”, “Three”).collect(Collectors.toList());
```
collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)— katulad ng , collect(collector)tanging ang mga parameter ay pinaghiwa-hiwalay para sa kaginhawahan ( suppliernagbibigay ng mga bagong bagay (mga lalagyan), halimbawa new ArrayList(), accumulatornagdaragdag ng isang elemento sa lalagyan, combinerpinagsasama ang mga bahagi ng stream nang magkasama);
reduce(T identity, BinaryOperator accumulator) - kino-convert ang lahat ng elemento ng stream sa isang object (kalkulahin ang kabuuan ng lahat ng elemento, o hanapin ang minimum na elemento), kunin muna ang object identityat ang unang elemento ng stream, ilapat ang function accumulatorat identitymaging resulta nito. Pagkatapos ang lahat ay nagpapatuloy para sa natitirang mga elemento.
```
int sum = Stream.of(1, 2, 3, 4, 5).reduce(10, (acc, x) -> acc + x);// = 25
```
reduce(BinaryOperator accumulator)— ang parehong paraan tulad ng sa itaas ngunit ang una ay nawawala identity, ito ang unang elemento ng stream

Optional min(Comparator comparator)
Ang opsyonal na max(Comparator comparator) ay naghahanap ng minimum/maximum na elemento batay sa naipasa na comparator;
findFirst()– bunutin ang unang elemento ng stream:
```
Stream.of(1, 2, 3, 4, 9).findFirst();
```
allMatch(Predicate predicate)— nagbabalik ng true kung ang lahat ng elemento ng stream ay nakakatugon sa kundisyon. Kung ang anumang elemento ay nakatagpo kung saan ang resulta ng pagtawag sa predicate function ay false , pagkatapos ay ihihinto ng operator ang pag-scan sa mga elemento at ibabalik ang false :
```
Stream.of(1, 2, 3, 4, 9).allMatch(x -> x <= 7);//false
```
anyMatch(Predicate predicate)— ay babalik ng true kung ang kahit isang elemento ng stream ay nakakatugon sa kundisyon predicate:
```
Stream.of(1, 2, 3, 4, 9).anyMatch(x -> x >= 7);//true
```
noneMatch(Predicate predicate)— ay babalik ng totoo kung, nang dumaan sa lahat ng elemento ng stream, wala sa kanila ang nasiyahan sa kundisyon predicate:
```
Stream.of(1, 2, 3, 4, 9).noneMatch(x -> x >= 7);//false
```

At sa wakas gusto kong tumingin sa ilang mga pamamaraan Collectors:

toList()— nangongolekta ng mga elemento sa List:

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

toSet()— nangongolekta ng mga elemento sa isang set:

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

counting()— Binibilang ang bilang ng mga elemento:

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

joining()
joining(CharSequence delimiter)

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)— nangongolekta ng mga elemento sa isang linya. Bilang karagdagan, maaari mong tukuyin ang isang separator, pati na rin ang isang prefix at suffix para sa buong sequence:

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)- isang kolektor na nagko-convert ng mga bagay sa int/long/doble at kinakalkula ang kabuuan.

Mga kapaki-pakinabang na link:

PS: huwag kang mahiya sa pagbuhos sa amin ng likes ^ : ^

Mga komento

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