Java Streams beherrschen: Ein vollständiger Leitfaden für Entwickler

Java Streams, eingeführt in Java 8, sind eine der leistungsstärksten Ergänzungen der Sprache. Sie ermöglichen funktionale Operationen an Sammlungen und Sequenzen und verändern unsere Herangehensweise an die Datenverarbeitung in Java. Streams vereinfachen Aufgaben wie das Filtern, Zuordnen und Sammeln von Daten und unterstützen gleichzeitig parallele Vorgänge zur Leistungsverbesserung. In diesem Beitrag werden wir die Grundlagen von Streams untersuchen, die von ihnen unterstützten Vorgänge besprechen und Beispiele bereitstellen, die Ihnen helfen, diese wichtige Funktion optimal zu nutzen.

Inhaltsverzeichnis

1.  What is Streams and why we need it?
2.  Types of Streams: Intermediate vs. Terminal
3.  Creating Streams in Java
4.  Intermediate Stream Operations
5.  Terminal Stream Operations
6.  Using Streams with Lambdas
7.  Conclusion

Was ist Streams und warum brauchen wir es?

Streams in Java bieten eine leistungsstarke Möglichkeit, Datensammlungen zu verarbeiten. Sie ermöglichen es uns, funktionale Operationen an Elementen einer Sammlung durchzuführen, wie z. B. Filtern und Transformieren, ohne die zugrunde liegenden Daten zu verändern. Streams helfen Entwicklern, sich auf das zu konzentrieren, was sie erreichen wollen, und nicht darauf, wie sie es erreichen können, und bieten eine Abstraktion auf höherer Ebene für die Datenverarbeitung.

Streams wurden in Java 8 zusammen mit Lambda-Ausdrücken und Funktionsschnittstellen eingeführt, um Java ausdrucksvoller zu machen und Boilerplate-Code zu reduzieren. Durch die Integration von Streams begann Java, das Paradigma der funktionalen Programmierung zu übernehmen, was einen saubereren, prägnanteren Code ermöglichte.

Hauptvorteile von Streams

• Deklarative Datenverarbeitung: Beschreiben Sie die Vorgänge, die Sie ausführen möchten, anstatt Schleifen und Bedingungen manuell zu verwalten.
• Unveränderlichkeit und Zustandslosigkeit: Stream-Vorgänge verändern die Quelldatenstruktur nicht.
• Parallele Verarbeitung: Unterstützung für parallele Streams, sodass Vorgänge problemlos auf mehrere Threads verteilt werden können.

Arten von Streams: Mittelstufe vs. Terminal

Streams werden in zwei Haupttypen eingeteilt:

• Zwischenoperationen: Diese Operationen transformieren den Stream und geben als Ergebnis einen anderen Stream zurück. Sie sind faul – das heißt, sie werden erst ausgeführt, wenn eine Terminaloperation aufgerufen wird.
• Terminaloperationen: Diese Operationen lösen die Datenverarbeitung des Streams aus und geben ein Nicht-Stream-Ergebnis zurück (z. B. eine Sammlung, einen einzelnen Wert oder einen booleschen Wert). Sobald eine Terminaloperation ausgeführt wird, gilt der Stream als verbraucht und kann nicht wiederverwendet werden.

Beispiel:

List<String> names = List.of("Alice", "Bob", "Charlie", "David");

// Intermediate (lazy) operations: filter and map
Stream<String> stream = names.stream()
                             .filter(name -> name.startsWith("A"))
                             .map(String::toUpperCase);

// Terminal operation: collect
List<String> filteredNames = stream.collect(Collectors.toList());
System.out.println(filteredNames); // Output: [ALICE]

In diesem Beispiel sind Filter und Map Zwischenoperationen, die erst ausgeführt werden, wenn die Terminaloperation Collect aufgerufen wird.

Streams in Java erstellen

Java bietet mehrere Möglichkeiten zum Erstellen von Streams, sodass Sie problemlos mit der Datenverarbeitung beginnen können.

• Aus Sammlungen

Die gängigste Methode zum Erstellen von Streams sind Sammlungen wie List, Set und Map.

1.  What is Streams and why we need it?
2.  Types of Streams: Intermediate vs. Terminal
3.  Creating Streams in Java
4.  Intermediate Stream Operations
5.  Terminal Stream Operations
6.  Using Streams with Lambdas
7.  Conclusion

• Aus Arrays

List<String> names = List.of("Alice", "Bob", "Charlie", "David");

// Intermediate (lazy) operations: filter and map
Stream<String> stream = names.stream()
                             .filter(name -> name.startsWith("A"))
                             .map(String::toUpperCase);

// Terminal operation: collect
List<String> filteredNames = stream.collect(Collectors.toList());
System.out.println(filteredNames); // Output: [ALICE]

• Mit Stream.of

List<String> names = List.of("Alice", "Bob", "Charlie");
Stream<String> nameStream = names.stream();

• Unendliche Streams (generierte Streams)

Java ermöglicht das Erstellen unendlicher Streams mit Stream.generate und Stream.iterate.

String[] namesArray = {"Alice", "Bob", "Charlie"};
Stream<String> nameStream = Arrays.stream(namesArray);

Intermediate Stream-Operationen

Zwischenoperationen geben einen neuen Stream zurück und sind verzögert. Dies bedeutet, dass sie nur ausgeführt werden, wenn eine Terminaloperation aufgerufen wird.

• filter(Prädikat)

Filtert Elemente basierend auf einer Bedingung.

Stream<String> stream = Stream.of("Alice", "Bob", "Charlie");

• map(Function)

Transformiert Elemente von einem Typ in einen anderen.

Stream<Double> randomNumbers = Stream.generate(Math::random).limit(5);
Stream<Integer> counting = Stream.iterate(0, n -> n + 1).limit(5);

• sortiert(Komparator)

Sortiert Elemente in natürlicher Reihenfolge oder basierend auf einem Komparator.

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());

• peek(Consumer)

Führt eine Aktion für jedes Element aus, was häufig zum Debuggen nützlich ist.

List<String> names = List.of("Alice", "Bob");
List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());

Terminal-Stream-Operationen

Terminaloperationen werden zuletzt ausgeführt, wodurch die eigentliche Datenverarbeitung ausgelöst wird und ein Endergebnis zurückgegeben wird.

• forEach(Consumer)

Führt eine Aktion für jedes Element im Stream aus.

List<String> names = List.of("Bob", "Alice", "Charlie");
List<String> sortedNames = names.stream()
                                .sorted()
                                .collect(Collectors.toList());

• sammeln(Sammler)

Sammelt die Elemente eines Streams in einer Sammlung, Liste, Menge oder anderen Datenstrukturen.

List<String> names = List.of("Alice", "Bob");
names.stream()
     .peek(name -> System.out.println("Processing " + name))
     .collect(Collectors.toList());

• count()

Zählt die Anzahl der Elemente im Stream.

List<String> names = List.of("Alice", "Bob");
names.stream().forEach(System.out::println);

• anyMatch(Predicate), allMatch(Predicate), noneMatch(Predicate)

Überprüft, ob eines, alle oder keines der Elemente einer bestimmten Bedingung entspricht.

List<String> names = List.of("Alice", "Bob");
Set<String> nameSet = names.stream().collect(Collectors.toSet());

• findFirst() und findAny()

Gibt eine optionale Beschreibung des ersten oder eines beliebigen Elements des Streams zurück.

List<String> names = List.of("Alice", "Bob");
long count = names.stream().count();

Verwenden von Streams mit Lambdas

Streams und Lambda-Ausdrücke gehen Hand in Hand. Da Streams auf funktionalen Schnittstellen basieren, arbeiten sie nahtlos mit Lambdas zusammen und ermöglichen so eine ausdrucksstarke und prägnante Datenverarbeitung.

Zum Beispiel das Filtern einer Namensliste, um Namen zu finden, die mit „A“ beginnen, und diese dann in Großbuchstaben umwandeln:

List<String> names = List.of("Alice", "Bob", "Charlie");
boolean hasAlice = names.stream().anyMatch(name -> name.equals("Alice"));

In diesem Beispiel:

• Filter benötigt einen Lambda-Namen -> name.startsWith("A") zum Filtern von Namen.
• map benötigt eine Methodenreferenz String::toUpperCase, um Namen in Großbuchstaben umzuwandeln.

Abschluss

Java Streams bringen funktionale Programmierfunktionen in Java und ermöglichen eine ausdrucksstarke und prägnante Datenbearbeitung. Wenn Sie den Unterschied zwischen Zwischen- und Terminaloperationen verstehen und wissen, wie Sie Streams effektiv erstellen und nutzen, können Sie die Lesbarkeit und Wartbarkeit Ihres Codes erheblich verbessern. Integrieren Sie Streams und Lambdas in Ihren Workflow, um sauberere und effizientere Java-Anwendungen zu schreiben.

Viel Spaß beim Streamen!

Das obige ist der detaillierte Inhalt vonJava Streams beherrschen: Ein vollständiger Leitfaden für Entwickler. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!