1. Pagsusuri
Sa tingin ko, baka naiinip ka na sa pag-aaral kung paano i-chain ang mga stream ng data. Gusto mong gumawa ng isang bagay sa wakas sa data.
Ang Stream
klase ay may tatlong karaniwang pamamaraan na hindi gumagawa ng mga stream, ngunit sa halip ay suriin kung anong uri ng data ang nasa kanila. Ang mga pamamaraang ito ay: anyMatch()
, allMatch()
, at noneMatch()
.
boolean anyMatch(rule)
paraan
Sinusuri ng pamamaraang ito kung ang stream ay may kahit man lang isang elemento na nakakatugon sa panuntunang ipinasa sa pamamaraan. Kung mayroong ganoong elemento, ang pamamaraan ay nagbabalik true
, kung hindi man false
.
Mga halimbawa
Code | Tandaan |
---|---|
|
|
|
|
|
|
Sa huling halimbawa, pananatilihin muna namin ang mga elementong mas mababa sa zero, at pagkatapos ay suriin namin ang resulta upang makita kung ang alinman sa mga na-filter na elemento ay mas malaki kaysa sa zero. Siyempre, wala na ang mga ganoong elemento.
boolean allMatch(rule) method
Sinusuri ng pamamaraang ito kung ang lahat ng elemento sa stream ay tumutugma sa panuntunan (kilala rin bilang isang panaguri). Ang panuntunan ay ipinasa bilang isang argumento sa pamamaraan:
Code | Tandaan |
---|---|
|
(lahat ng elementong mas malaki sa zero) |
|
(may mga elemento ba na mas mababa sa o katumbas ng zero?) |
|
(napanatili namin ang mga elemento na mas mababa sa zero) |
Sa huling halimbawa, pinahihintulutan muna namin ang mga elementong mas mababa sa zero na dumaan sa filter, at pagkatapos ay tinitingnan namin kung ang lahat ng mga napanatili na elemento ay mas mababa sa zero. Ang tseke ay nagbubunga ng isang positibong resulta.
boolean noneMatch(rule) method
Sinusuri ng noneMatch()
pamamaraan kung ang stream ay walang mga elemento na tumutugma sa ipinasa na panuntunan. Ito ay tulad ng kabaligtaran ng anyMatch()
pamamaraan.
Code | Tandaan |
---|---|
|
|
|
|
|
|
2. Utility classes: Optional
klase
Minsan napakahirap para sa mga programmer na magtrabaho kasama null
ang mga sanggunian. Halimbawa, ipagpalagay na naghahambing ka ng dalawang string. Kung ang parehong mga variable ay hindi null
, pagkatapos ay maaari kang tumawag lamang s1.equals(s2)
, at lahat ay gagana. Ngunit kung s1
maaari null
, kailangan mong magsulat ng code na humahawak sa sitwasyong ito upang maiwasan ang isang NullPointerException
.
Iyon ang dahilan kung bakit ang mga programmer ay dumating sa Optional<T>
klase ng utility. Ang code nito ay halos ganito:
Code | Tandaan |
---|---|
|
Sinusuri kung ang halaga ay hindi null Sinusuri kung ang halaga ay null Ibinabalik ang nakaimbak na halaga. Naghahagis ng exception kung null ang value. Ibinabalik ang nakaimbak na hindi null na halaga. O kung ang nakaimbak na halaga ay null , pagkatapos ay ibinabalik ang halagang ipinasa bilang isang argumento ng pamamaraan Ibinabalik ang nakaimbak na hindi null na halaga o naglalagay ng pagbubukod kung ang halaga ay null. |
Ang layunin ng klase na ito ay simpleng mag-imbak ng isang bagay na T (isang sanggunian sa isang bagay na ang uri ay T). Ang object reference sa loob ng isang Optional<T>
object ay maaaring null
.
Hinahayaan ng klase na ito ang mga programmer na magsulat ng bahagyang mas magandang code. Ihambing natin:
Paggamit ng Opsyonal | Hindi gumagamit ng Opsyonal |
---|---|
|
|
Ang isang Optional
bagay ay palaging maihahambing sa isa pang Optional
bagay gamit ang equals
pamamaraan, kahit na nag-iimbak sila null
ng mga sanggunian.
Sa madaling salita, Optional
hinahayaan ka ng klase na magsulat ng "magandang" mga tseke para sa null
at "magandang" mga aksyon kung sakaling ang isang Optional
bagay ay nag-imbak ng isang null
halaga.
3. Paghahanap ng mga elemento
Balik na tayo sa Stream
klase. Ang Stream
klase ay may 4 pang paraan na nagbibigay-daan sa iyong maghanap ng mga elemento sa isang stream. Ang mga pamamaraang ito ay findFirst()
, findAny()
, min()
, at max()
.
Optional<T> findFirst()
paraan
Ibinabalik lang ng findFirst()
pamamaraan ang unang elemento sa stream. Iyon lang ang ginagawa nito.
Ang mas kawili-wiling bagay na dapat tandaan dito ay ang pamamaraan ay hindi nagbabalik ng isang T
bagay, ngunit isang Optional<T>
bagay na pambalot. Tinitiyak nito na ang pamamaraan ay hindi na babalik null
pagkatapos mabigong makahanap ng isang bagay.
Halimbawa:
ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String str = list.stream().findFirst().get(); // Hello
Para sa higit na paglilinaw, hatiin natin ang huling linya sa ilang linya:
ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
Stream<String> stream = list.stream();
Optional<String> result = stream.findFirst();
String str = result.get(); // Hello
Ang huling get()
paraan ay kinukuha lamang ang halagang nakaimbak sa loob ng Optional
bagay.
Optional<T> findAny()
paraan
Ang findAny()
pamamaraan ay nagbabalik ng anumang elemento mula sa stream at nagtatapos doon. Ang pamamaraang ito ay katulad ng findFirst()
, ngunit ito ay mahusay para sa mga stream na ginagamit sa parallel na operasyon.
Kapag pinoproseso ang mga stream nang magkatulad, maaaring ito ay isang elemento na natagpuan na sa ilang bahagi ng isang stream, ngunit hindi pa malinaw kung ito ang una o hindi.
Kung maraming elemento ang tumugma sa lahat ng mga filter, at mahalaga para sa programmer na makuha nang eksakto ang una sa kanila, kung gayon ang findFirst()
pamamaraan ay kung ano ang dapat na tawagan. Kung alam ng programmer na sa katotohanan 0 o 1 elemento ay tutugma sa lahat ng mga filter, kung gayon sapat na ang tumawag lamang findAny()
— at ito ay magiging mas mabilis.
Optional<T> min(Comparator<T>)
paraan
Ang min()
pamamaraan ay gumagamit ng isang comparator
bagay upang ihambing ang lahat ng mga elemento sa stream at ibinabalik ang pinakamababang elemento. Ang pinaka-maginhawang paraan upang tukuyin ang isang comparator object ay gamit ang isang lambda function.
Halimbawa ng paghahanap para sa pinakamaikling string:
ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String min = list.stream().min( (s1, s2)-> s1.length()-s2.length() ).get();
Optional<T> max(Comparator<T>)
paraan
Ang max()
pamamaraan ay gumagamit ng isang comparator
bagay upang ihambing ang lahat ng mga elemento sa stream at ibinabalik ang maximum na elemento. Ang pinaka-maginhawang paraan upang tukuyin ang isang comparator object ay gamit ang isang lambda function.
Halimbawa ng paghahanap para sa pinakamahabang string:
ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String max = list.stream().max( (s1, s2)-> s1.length()-s2.length() ).get();
GO TO FULL VERSION