Munka folyamokkal, 3. rész

1. Ellenőrzés

Azt hiszem, már unod, hogy megtanulod, hogyan kapcsold össze az adatfolyamokat. Szeretnél végre valamit kezdeni az adatokkal.

Az Streamosztály három szabványos metódussal rendelkezik, amelyek nem hoznak létre folyamokat, hanem ellenőrzik, hogy milyen adatok vannak bennük. Ezek a módszerek: anyMatch(), allMatch(), és noneMatch().

boolean anyMatch(rule)módszer

Ez a metódus ellenőrzi, hogy az adatfolyamnak van-e legalább egy olyan eleme, amely megfelel a metódusnak átadott szabálynak. Ha van ilyen elem, akkor a metódus a -t adja vissza true, ellenkező esetben a -t false.

Példák

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

Az utolsó példában először csak azokat az elemeket tartjuk meg, amelyek kisebbek nullánál, majd ellenőrizzük az eredményt, hogy a szűrt elemek közül valamelyik nagyobb-e nullánál. Természetesen ilyen elemek már nincsenek.

logikai allMatch(rule) metódus

Ez a módszer ellenőrzi, hogy az adatfolyam minden eleme megfelel-e a szabálynak (más néven predikátum). A szabály a metódus argumentumaként kerül átadásra:

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

Az utolsó példában először csak a nullánál kisebb elemeket engedjük át a szűrőn, majd ellenőrizzük, hogy az összes megtartott elem kisebb-e nullánál. Az ellenőrzés pozitív eredményt ad.

logikai noneMatch(rule) metódus

A noneMatch()metódus ellenőrzi, hogy az adatfolyamban nincsenek-e olyan elemek, amelyek megfelelnek az átadott szabálynak. Ez olyan, mint a anyMatch()módszer ellentéte.

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. Hasznossági osztályok: Optionalosztály

Néha nagyon kényelmetlen a programozóknak a referenciákkal dolgozni null. Tegyük fel például, hogy két karakterláncot hasonlít össze. Ha mindkét változó nem null, akkor egyszerűen hívhatja a -t s1.equals(s2), és minden működni fog. De ha s1lehetséges null, akkor olyan kódot kell írnia, amely kezeli ezt a helyzetet, hogy elkerülje a NullPointerException.

Ezért találták ki a programozók a Optional<T>hasznossági osztályt. A kódja nagyjából így néz ki:

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

Ennek az osztálynak a célja egyszerűen egy T objektum tárolása (hivatkozás egy T típusú objektumra). Az objektum hivatkozása egy Optional<T>objektumon belül lehet null.

Ez az osztály lehetővé teszi a programozóknak, hogy valamivel szebb kódot írjanak. Hasonlítsuk össze:

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

Egy Optionalobjektum mindig összehasonlítható egy másik Optionalobjektummal a metódus segítségével equals, még akkor is, ha hivatkozásokat tárolnak null.

Egyszerűen szólva, az Optionalosztály lehetővé teszi "szép" ellenőrzések nullés "szép" műveletek írását abban az esetben, ha egy Optionalobjektum nullértéket tárol.

3. Elemek megtalálása

Térjünk vissza az osztályhoz Stream. Az Streamosztály további 4 metódussal rendelkezik, amelyek segítségével elemeket kereshet egy adatfolyamban. Ezek a módszerek a findFirst(), findAny(), min()és max().

Optional<T> findFirst()módszer

A findFirst()metódus egyszerűen visszaadja az adatfolyam első elemét. Ez minden.

Itt még érdekesebb megjegyezni, hogy a metódus nem objektumot ad vissza T, hanem egy Optional<T>burkoló objektumot. Ez biztosítja, hogy a metódus soha ne térjen vissza, nullmiután nem talált egy objektumot.

Példa:

ArrayList<String> list = new ArrayList<String>();
Collections.addAll(list, "Hello", "how's", "life?");
String str = list.stream().findFirst().get(); // Hello

A jobb érthetőség kedvéért bontsuk fel az utolsó sort több sorra:

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

Az utolsó get()módszer egyszerűen lekéri az objektumon belül tárolt értéket Optional.

Optional<T> findAny()módszer

A findAny()metódus bármely elemet visszaad a folyamból, és ott ér véget. Ez a módszer hasonló a -hoz findFirst(), de nagyszerű a párhuzamos műveletekben használt adatfolyamokhoz.

A folyamok párhuzamos feldolgozása során előfordulhat, hogy egy elemet már találtak a folyam valamely részében, de még nem világos, hogy ez az első vagy sem.

Ha sok elem illeszkedett az összes szűrőhöz, és fontos, hogy a programozó pontosan az elsőt kapja meg, akkor a findFirst()metódust kell hívni. Ha a programozó tudja, hogy a valóságban 0 vagy 1 elem fog megfelelni az összes szűrőnek, akkor elég egyszerűen hívni findAny()– és ez gyorsabb lesz.

Optional<T> min(Comparator<T>)módszer

A min()metódus egy objektumot használ comparatoraz adatfolyam összes elemének összehasonlítására, és a minimális elemet adja vissza. A komparátor objektum meghatározásának legkényelmesebb módja a lambda függvény.

Példa a legrövidebb karakterlánc keresésére:

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>)módszer

A max()metódus egy objektumot használ comparatoraz adatfolyam összes elemének összehasonlítására, és a maximális elemet adja vissza. A komparátor objektum meghatározásának legkényelmesebb módja a lambda függvény.

Példa a leghosszabb karakterlánc keresésére:

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