Paggawa gamit ang mga stream, bahagi 3

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 Streamklase 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

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.anyMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).anyMatch(x -> x > 0);

false

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:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.allMatch(x -> x > 0);

true

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.allMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).allMatch(x -> x < 0);

true

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.

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.noneMatch(x -> x > 0);

false

Stream<Integer> stream = Stream.of(1, -2, 3, -4, 5);
boolean result = stream.filter(x -> x < 0).noneMatch(x -> x > 0);

true

2. Utility classes: Optionalklase

Minsan napakahirap para sa mga programmer na magtrabaho kasama nullang 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 s1maaari 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:

class Optional<Type>
{
   private final Type value;
   private Optional() { this.value = null;}
   private Optional(value) { this.value = value;}
   public static <Type> Optional<Type> of(Type value)
   {
      return new Optional<Type>(value);
   }

   public boolean isPresent()
   {
      return value != null;
   }

   public boolean isEmpty()
   {
      return value == null;
   }

   public Type get()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }

   public Type orElse(Type other)
   {
      return value != null ? value : other;
   }

   public Type orElseThrow()
   {
      if (value == null)
      {
         throw new NoSuchElementException();
      }
      return value;
   }
}

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:

public void printString(String s)
{
   Optional<String> str = Optional.ofNullable(s);
   System.out.println(str.orElse(""));
}

public void printString(String s)
{
   String str = s != null ? s : "";
   System.out.println(str)
}

Ang isang Optionalbagay ay palaging maihahambing sa isa pang Optionalbagay gamit ang equalspamamaraan, kahit na nag-iimbak sila nullng mga sanggunian.

Sa madaling salita, Optionalhinahayaan ka ng klase na magsulat ng "magandang" mga tseke para sa nullat "magandang" mga aksyon kung sakaling ang isang Optionalbagay ay nag-imbak ng isang nullhalaga.

3. Paghahanap ng mga elemento

Balik na tayo sa Streamklase. Ang Streamklase 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 Tbagay, ngunit isang Optional<T>bagay na pambalot. Tinitiyak nito na ang pamamaraan ay hindi na babalik nullpagkatapos 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 Optionalbagay.

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