Stream-Filter in Java

1. Stream mit den Methoden filter() und collect() in Java
2. Stream mit der Methode filter() und forEach() in Java
3. Stream mit filter() und mehreren Bedingungen in Java
4. Streamen mit filter() und map() in Java
5. Stream mit Stapelung mehrerer filter()-Methoden in Java

Dieses Tutorial stellt die Stream-API und ihre filter()-Methode in Java vor. In Java ist ein Stream eine Sammlung von Objekten.

Ein Stream speichert keine Daten und ist daher keine Datenstruktur. Ein Stream verfügt über verschiedene Methoden, die zusammengeführt werden können, um das gewünschte Ergebnis zu erzielen.

Eine dieser Methoden ist die filter-Methode. Wir werden verschiedene Beispiele sehen, die die Operation filter() dieses Artikels verwenden.

Lassen Sie uns zuerst die Operation filter() verstehen. Die Methode filter() gibt einen neuen Stream mit Elementen zurück, die dem als Argument übergebenen Prädikat entsprechen.

Mit anderen Worten, die Operation filter() wird verwendet, um einen eingehenden Stream zu filtern und einen neuen Stream auszugeben. Die Syntax für diese Methode lautet:

Stream<T> filter(Predicate<? super T> predicate)

Ein Prädikat ist eine funktionale Schnittstelle, was bedeutet, dass wir hier eine Lambda-Funktion oder eine Methodenreferenz übergeben können. Sehen wir uns nun einige Beispiele an.

Stream mit den Methoden filter() und collect() in Java

Die Operation collect() ist eine Art Terminaloperation.

Terminaloperationen werden am Ende auf einen Stream angewendet, um ein Ergebnis zu erzeugen. Nachdem ein Terminaloperator angewendet wurde, wird der Stream konsumiert und kann nicht mehr konsumiert werden.

Die Operation collect() gibt die Ausgabe der Zwischenoperationen zurück; es kann auch verwendet werden, um die Ausgabe in die gewünschte Datenstruktur umzuwandeln. Sehen Sie sich das Beispiel unten an.

Angenommen, wir haben eine Liste aller Schüler einer Klasse und möchten eine neue Liste erstellen, die alle Schülernamen außer einem enthält. Angenommen, ein Schüler hat die Schule verlassen.

Wir können dies mit diesem angegebenen Code tun.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> students = Arrays.asList("Kashish", "Riyan", "Ritu");

    List<String> new_students =
        students.stream().filter(sName -> !"Riyan".equals(sName)).collect(Collectors.toList());

    new_students.forEach(System.out::println);
  }
}

Ausgabe:

Kashish
Ritu

In diesem Code wird zunächst ein Strom von Studentennamen erstellt.

Der Stream wird dann mit einem Prädikat gefiltert: alle Namen, die nicht gleich Riyan sind. Die Operation filter erzeugt einen neuen Stream mit allen Elementen, die dieses Prädikat erfüllen.

Der neu erstellte Stream wird dann mit der Operation collect in eine List umgewandelt.

Stream mit der Methode filter() und forEach() in Java

Die Methode forEach() ist ebenfalls eine Terminaloperation. Es wendet die als Argument übergebene Funktion auf jedes Stream-Element an.

Es funktioniert wie eine foreach-Schleife, funktioniert aber nur für Streams. Siehe das Beispiel unten.

Angenommen, wir möchten alle Zahlen drucken, die durch fünf teilbar sind. Der folgende Code funktioniert so.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    numbers.stream().filter(n -> n % 5 == 0).forEach(System.out::println);
  }
}

Ausgabe:

5
10
25

Stream mit filter() und mehreren Bedingungen in Java

Wir können mehrere Bedingungen mit logischen Operatoren an die Operation filter() übergeben, um verfeinerte Ergebnisse zu erhalten. Angenommen, wir wollen alle Elemente finden, die durch fünf teilbar und größer als zehn sind; siehe das Beispiel unten.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    numbers.stream().filter(n -> n % 5 == 0 && n > 10).forEach(System.out::println);
  }
}

Ausgabe:

25

Streamen mit filter() und map() in Java

Die Operation map() ist genauso wie die Operation forEach().

Es wendet eine Funktion auf jedes Element des Streams an. Es ist eher eine Zwischenoperation als eine Endoperation.

Angenommen, wir müssen alle durch 5 teilbaren Elemente quadrieren. Wir können dies tun, indem wir die Operationen filter und map in einer Pipeline verarbeiten.

Siehe das Beispiel unten.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 11, 10, 25);

    List<Integer> new_numbers =
        numbers.stream().filter(n -> n % 5 == 0).map(x -> x * x).collect(Collectors.toList());

    new_numbers.forEach(System.out::println);
  }
}

Ausgabe:

25
100
625

Im obigen Code wird zunächst die Liste der Ganzzahlen gefiltert. Nach dem Filtern der Liste wird jedes im Stream verbleibende Element mit der Operation map() quadriert.

Zuletzt wandeln wir den Stream in die Liste um und speichern ihn in der Liste new_numbers.

Stream mit Stapelung mehrerer filter()-Methoden in Java

Wir können die Methode filter() stapeln, indem wir sie nacheinander anwenden, um ein verfeinertes Ergebnis zu erhalten.

Angenommen, wir wollen zuerst die Strings filtern, deren Länge größer als drei ist, und dann die Strings filtern, die stack als Teilstring enthalten. Wir können dies tun, indem wir das folgende Codebeispiel verwenden.

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> str = Arrays.asList("Hello", "I", "Love", "Delftstack");

    List<String> new_string = str.stream()
                                  .filter(n -> n.length() > 3)
                                  .filter(n -> n.contains("stack"))
                                  .collect(Collectors.toList());

    new_string.forEach(System.out::println);
  }
}

Ausgabe:

Delftstack

Beachten Sie, dass der obige Code der Verwendung mehrerer Bedingungen mit dem Operator && entspricht. Schauen Sie unten:

import java.util.*;
import java.util.stream.Collectors;
public class MyClass {
  public static void main(String args[]) {
    List<String> str = Arrays.asList("Hello", "I", "Love", "Delftstack");

    List<String> new_string = str.stream()
                                  .filter(n -> n.length() > 3 && n.contains("stack"))
                                  .collect(Collectors.toList());

    new_string.forEach(System.out::println);
  }
}

Ausgabe:

Delftstack