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.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")
- 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.
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,x
katumbas ng isang elemento ng koleksyon para sa enumeration (tulad ng safor 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 ,forEach
na kung saan ay terminal (panghuling) analogue ng enumerationfor each
(ExpressionSystem.out::println
na 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)
- 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));
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.function
Sinusuri 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 interfaceFunction<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 ngmap
, ginagamit ang mga ito upang mag-convert sa isang primitive stream.
[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 map
nagko-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)
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
-
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 (supplier
nagbibigay ng mga bagong bagay (mga lalagyan), halimbawanew ArrayList()
,accumulator
nagdaragdag ng isang elemento sa lalagyan,combiner
pinagsasama 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
identity
at ang unang elemento ng stream, ilapat ang functionaccumulator
atidentity
maging 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 nawawalaidentity
, ito ang unang elemento ng streamOptional 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 kundisyonpredicate
: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 kundisyonpredicate
:Stream.of(1, 2, 3, 4, 9).noneMatch(x -> x >= 7);//false
Collectors
:
-
toList()
— nangongolekta ng mga elemento saList
: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.
GO TO FULL VERSION