Arbeiten mit Threads, Teil 3

1. Überprüfung

Ich glaube, es ist Ihnen vielleicht schon zu langweilig, zu lernen, wie man Datenströme verkettet. Sie möchten endlich etwas mit den Daten anfangen.

Die StreamKlasse verfügt über drei Standardmethoden, die keine Streams erstellen, sondern prüfen, welche Art von Daten darin enthalten sind. Diese Methoden sind: anyMatch(), allMatch(), und noneMatch().

boolean anyMatch(rule)Methode

Diese Methode prüft, ob der Stream mindestens ein Element enthält, das die an die Methode übergebene Regel erfüllt. Wenn ein solches Element vorhanden ist, gibt die Methode zurück true, andernfalls false.

Beispiele

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

Im letzten Beispiel behalten wir zunächst nur die Elemente bei, die kleiner als Null sind, und überprüfen dann das Ergebnis, um festzustellen, ob eines der gefilterten Elemente größer als Null ist. Natürlich gibt es solche Elemente nicht mehr.

boolesche allMatch(rule)-Methode

Diese Methode prüft, ob alle Elemente im Stream der Regel (auch als Prädikat bezeichnet) entsprechen. Die Regel wird als Argument an die Methode übergeben:

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

Im letzten Beispiel lassen wir zunächst nur Elemente durch den Filter, die kleiner als Null sind, und prüfen dann, ob alle zurückgehaltenen Elemente kleiner als Null sind. Die Prüfung ergibt ein positives Ergebnis.

boolesche Methode noneMatch(rule).

Die noneMatch()Methode prüft, ob der Stream keine Elemente enthält, die der übergebenen Regel entsprechen. Es ist sozusagen das Gegenteil der anyMatch()Methode.

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-Klassen: OptionalKlasse

Manchmal ist es für Programmierer sehr umständlich, mit nullReferenzen zu arbeiten. Angenommen, Sie vergleichen zwei Zeichenfolgen. Wenn beide Variablen nicht vorhanden sind null, können Sie einfach aufrufen s1.equals(s2)und alles wird funktionieren. Wenn dies jedoch s1der Fall sein könnte null, müssen Sie Code schreiben, der diese Situation behandelt, um eine NullPointerException.

Aus diesem Grund haben Programmierer die Utility-Klasse entwickelt Optional<T>. Sein Code sieht ungefähr so ​​aus:

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

Der Zweck dieser Klasse besteht lediglich darin, ein T-Objekt zu speichern (eine Referenz auf ein Objekt vom Typ T). Die Objektreferenz innerhalb eines Optional<T>Objekts kann sein null.

Mit dieser Klasse können Programmierer etwas schöneren Code schreiben. Lass uns vergleichen:

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

Ein Objekt kann mit der Methode immer mit einem anderen Objekt Optionalverglichen werden , auch wenn diese Referenzen speichern.Optionalequalsnull

Einfach ausgedrückt können Sie mit der OptionalKlasse „schöne“ Prüfungen nullund „schöne“ Aktionen für den Fall schreiben, dass ein OptionalObjekt einen nullWert speichert.

3. Elemente finden

Kehren wir zur StreamKlasse zurück. Die StreamKlasse verfügt über vier weitere Methoden, mit denen Sie nach Elementen in einem Stream suchen können. Diese Methoden sind findFirst(), findAny(), min()und max().

Optional<T> findFirst()Methode

Die findFirst()Methode gibt einfach das erste Element im Stream zurück. Das ist alles, was es tut.

Interessanter ist hier, dass die Methode kein TObjekt, sondern ein Optional<T>Wrapper-Objekt zurückgibt. Dadurch wird sichergestellt, dass die Methode niemals zurückkehrt, nullnachdem ein Objekt nicht gefunden wurde.

Beispiel:

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

Zur besseren Verdeutlichung teilen wir die letzte Zeile in mehrere Zeilen auf:

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

Die letzte get()Methode besteht einfach darin, den im OptionalObjekt gespeicherten Wert abzurufen.

Optional<T> findAny()Methode

Die findAny()Methode gibt ein beliebiges Element aus dem Stream zurück und endet dort. Diese Methode ähnelt der von findFirst(), eignet sich jedoch hervorragend für Streams, die in parallelen Vorgängen verwendet werden.

Bei der parallelen Verarbeitung von Streams kann es sein, dass ein Element bereits in einem Teil eines Streams gefunden wurde, es aber noch nicht klar ist, ob es das erste ist oder nicht.

Wenn viele Elemente mit allen Filtern übereinstimmen und es für den Programmierer wichtig ist, genau das erste davon zu erhalten, sollte die findFirst()Methode aufgerufen werden. Wenn der Programmierer weiß, dass in Wirklichkeit 0 oder 1 Element allen Filtern entspricht, genügt ein einfacher Aufruf findAny()– und das geht schneller.

Optional<T> min(Comparator<T>)Methode

Die min()Methode vergleicht mithilfe eines comparatorObjekts alle Elemente im Stream und gibt das minimale Element zurück. Der bequemste Weg, ein Komparatorobjekt zu definieren, ist die Verwendung einer Lambda-Funktion.

Beispiel für die Suche nach der kürzesten Zeichenfolge:

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

Die max()Methode vergleicht mithilfe eines comparatorObjekts alle Elemente im Stream und gibt das maximale Element zurück. Der bequemste Weg, ein Komparatorobjekt zu definieren, ist die Verwendung einer Lambda-Funktion.

Beispiel für die Suche nach der längsten Zeichenfolge:

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