Wie man eine Sammlung mit der Stream API in Java filtert

Einführung

Die Java Stream API bietet eine leistungsstarke und vielseitige Möglichkeit, mit Datenkollektionen zu arbeiten. In diesem Tutorial werden wir untersuchen, wie Sie die Stream API nutzen können, um Kollektionen zu filtern und so effizient die benötigten Daten zu extrahieren. Egal, ob Sie ein Java-Anfänger oder ein erfahrener Entwickler sind, dieser Leitfaden wird Sie mit den erforderlichen Kenntnissen und Fähigkeiten ausstatten, um Ihre Datenverarbeitungsprozesse zu optimieren.

Einführung in die Java Stream API

Die Java Stream API ist ein leistungsstarkes Feature, das in Java 8 eingeführt wurde und es Ihnen ermöglicht, Datenkollektionen in deklarativer und funktionaler Art und Weise zu verarbeiten. Streams bieten eine Möglichkeit, verschiedene Operationen auf Daten durchzuführen, wie Filtern, Abbilden, Sortieren und Reduzieren, ohne dass explizite Iteration oder veränderlicher Zustand erforderlich ist.

Streams verstehen

Ein Stream ist eine Sequenz von Elementen, die verschiedene Operationen unterstützt, um Berechnungen auf diesen Elementen durchzuführen. Streams können aus verschiedenen Datenquellen erstellt werden, wie Kollektionen, Arrays oder sogar I/O-Ressourcen. Streams bieten eine flüssige API (fluent API), die es Ihnen ermöglicht, mehrere Operationen zu verketten, wodurch Ihr Code ausdrucksstärker und lesbarer wird.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();
stream.filter(n -> n % 2 == 0)
     .map(n -> n * 2)
     .forEach(System.out::println);

Im obigen Beispiel erstellen wir einen Stream aus einer Liste von ganzen Zahlen, filtern die geraden Zahlen, multiplizieren sie mit 2 und geben dann die Ergebnisse aus.

Vorteile der Verwendung von Streams

Deklarative Programmierung: Streams ermöglichen es Ihnen, Ihre Absicht auf eine deklarativere Weise auszudrücken, indem Sie sich auf das konzentrieren, was Sie erreichen möchten, anstatt wie Sie es erreichen.
Parallelität: Streams können einfach parallelisiert werden, sodass Sie die Vorteile von Mehrkernprozessoren nutzen und die Leistung verbessern können.
Lazy Evaluation (Lazy-Evaluation): Streams sind lazy, was bedeutet, dass Operationen erst ausgeführt werden, wenn das endgültige Ergebnis benötigt wird, was die Effizienz verbessern kann.
Fluent API: Die Stream API bietet eine flüssige und ausdrucksstarke Möglichkeit, mehrere Operationen zu verketten, wodurch Ihr Code lesbarer und wartbarer wird.

Exploration von Stream-Operationen

Streams bieten eine Vielzahl von Operationen, die Sie verwenden können, um Ihre Daten zu manipulieren. Einige der häufigsten Operationen sind:

Filtern: Auswählen von Elementen basierend auf einem gegebenen Prädikat.
Abbilden: Transformieren von Elementen mit einer Funktion.
Sortieren: Ordnen von Elementen basierend auf einem Vergleicher.
Reduzieren: Kombinieren von Elementen zu einem einzigen Ergebnis.
Sammeln: Sammeln der Ergebnisse in einer neuen Datenstruktur.

In den folgenden Abschnitten werden wir tiefer in die spezifische Verwendung der Stream API zum Filtern von Kollektionen eintauchen.

Filtern von Kollektionen mit Streams

Das Filtern ist eine der häufigsten Operationen, die mit der Java Stream API auf Kollektionen durchgeführt werden. Das Filtern ermöglicht es Ihnen, eine Teilmenge von Elementen aus einer Kollektion basierend auf einem gegebenen Prädikat auszuwählen.

Anwenden von Filtern

Die filter()-Methode wird verwendet, um einen Filter auf einen Stream anzuwenden. Diese Methode nimmt einen Lambda-Ausdruck oder eine Methodenreferenz als Argument, das die Filterbedingung darstellt.

List<String> names = Arrays.asList("John", "Jane", "Bob", "Alice");
Stream<String> filteredNames = names.stream()
                                   .filter(name -> name.startsWith("J"));
filteredNames.forEach(System.out::println);

Im obigen Beispiel erstellen wir einen Stream aus einer Liste von Namen und verwenden dann die filter()-Methode, um nur die Namen auszuwählen, die mit dem Buchstaben "J" beginnen.

Verkettung mehrerer Filter

Sie können mehrere filter()-Aufrufe verketten, um mehrere Filterbedingungen auf einen Stream anzuwenden.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Stream<Integer> filteredNumbers = numbers.stream()
                                        .filter(n -> n % 2 == 0)
                                        .filter(n -> n > 5);
filteredNumbers.forEach(System.out::println);

In diesem Beispiel filtern wir zunächst die Zahlen, um nur die geraden Zahlen auszuwählen, und wenden dann einen zweiten Filter an, um nur die geraden Zahlen größer als 5 auszuwählen.

Kombinieren von Filtern mit anderen Operationen

Das Filtern kann mit anderen Stream-Operationen wie Abbilden, Sortieren und Reduzieren kombiniert werden, um komplexere Daten Transformationen zu erstellen.

List<Person> persons = Arrays.asList(
    new Person("John", 30),
    new Person("Jane", 25),
    new Person("Bob", 35),
    new Person("Alice", 28)
);

List<String> youngAdultNames = persons.stream()
                                     .filter(p -> p.getAge() >= 18 && p.getAge() < 30)
                                     .map(Person::getName)
                                     .collect(Collectors.toList());

System.out.println(youngAdultNames);

In diesem Beispiel filtern wir zunächst die Liste der Person-Objekte, um nur die jungen Erwachsenen (zwischen 18 und 30 Jahren alt) auszuwählen, dann bilden wir die Name-Eigenschaft jedes Person-Objekts ab und sammeln schließlich die Ergebnisse in einer neuen Liste.

Indem Sie die Macht des Filterns mit der Java Stream API verstehen, können Sie Ihre Datenkollektionen effektiv manipulieren und verarbeiten. Im nächsten Abschnitt werden wir weitere praktische Beispiele für die Anwendung von Filtern untersuchen.

Anwenden von Filtern: Praktische Beispiele

Nachdem Sie nun die Grundlagen des Filterns mit der Java Stream API gut verstanden haben, wollen wir einige praktische Beispiele betrachten, um Ihr Wissen zu festigen.

Filtern von Strings

Angenommen, Sie haben eine Liste von Strings und möchten nur die auswählen, die eine bestimmte Länge haben oder mit einem bestimmten Zeichen beginnen.

List<String> words = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");

// Filter words with length greater than 5 characters
List<String> longWords = words.stream()
                              .filter(word -> word.length() > 5)
                              .collect(Collectors.toList());
System.out.println(longWords); // [banana, cherry, elderberry]

// Filter words starting with 'a'
List<String> wordsStartingWithA = words.stream()
                                      .filter(word -> word.startsWith("a"))
                                      .collect(Collectors.toList());
System.out.println(wordsStartingWithA); // [apple, date]

Filtern von Zahlen

Sie können die Stream API auch verwenden, um numerische Daten wie ganze Zahlen oder Fließkommazahlen zu filtern.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Filter even numbers
List<Integer> evenNumbers = numbers.stream()
                                  .filter(n -> n % 2 == 0)
                                  .collect(Collectors.toList());
System.out.println(evenNumbers); // [2, 4, 6, 8, 10]

// Filter numbers greater than 5
List<Integer> numbersGreaterThan5 = numbers.stream()
                                          .filter(n -> n > 5)
                                          .collect(Collectors.toList());
System.out.println(numbersGreaterThan5); // [6, 7, 8, 9, 10]

Filtern von benutzerdefinierten Objekten

Sie können auch Filter auf Kollektionen von benutzerdefinierten Objekten wie Person-Objekten anwenden.

class Person {
    private String name;
    private int age;

    // Getters, setters, and constructor
}

List<Person> persons = Arrays.asList(
    new Person("John", 30),
    new Person("Jane", 25),
    new Person("Bob", 35),
    new Person("Alice", 28)
);

// Filter persons older than 30
List<Person> personsOlderThan30 = persons.stream()
                                        .filter(p -> p.getAge() > 30)
                                        .collect(Collectors.toList());
System.out.println(personsOlderThan30); // [Person(name=Bob, age=35)]

// Filter persons with names starting with 'J'
List<Person> personsWithNameStartingWithJ = persons.stream()
                                                  .filter(p -> p.getName().startsWith("J"))
                                                  .collect(Collectors.toList());
System.out.println(personsWithNameStartingWithJ); // [Person(name=John, age=30), Person(name=Jane, age=25)]

Durch die Betrachtung dieser praktischen Beispiele sollten Sie nun besser verstehen, wie Sie die filter()-Methode effektiv nutzen können, um Ihre Kollektionen in Java zu manipulieren.

Zusammenfassung

Am Ende dieses Tutorials werden Sie einen soliden Überblick darüber haben, wie Sie die Java Stream API nutzen können, um Kollektionen zu filtern. Sie werden über die verschiedenen verfügbaren Filterungsmethoden wie filter(), distinct() und limit() erfahren und lernen, wie Sie sie auf Ihre spezifischen Anwendungsfälle anwenden können. Mit den erworbenen Kenntnissen können Sie effizienteren und wartbareren Java-Code schreiben, Ihre Datenverarbeitungsprozesse optimieren und das volle Potenzial der Stream API ausschöpfen.