Stream wurde eingeführt in Java 8 Die Stream-API wird zum Verarbeiten von Objektsammlungen verwendet. Ein Stream in Java ist eine Folge von Objekten, die verschiedene Methoden unterstützt, die per Pipeline verarbeitet werden können, um das gewünschte Ergebnis zu erzielen. 

Verwendung von Stream in Java

Die Verwendungsmöglichkeiten von Stream in Java werden unten aufgeführt:

• Die Stream-API ist eine Möglichkeit, Sammlungen von Objekten auszudrücken und zu verarbeiten.
• Ermöglichen Sie uns die Durchführung von Vorgängen wie Filtern, Zuordnen, Reduzieren und Sortieren.

So erstellen Sie einen Java-Stream

Die Erstellung eines Java-Streams ist einer der grundlegendsten Schritte, bevor die Funktionalitäten des Java-Streams berücksichtigt werden. Nachfolgend finden Sie die Syntax zum Deklarieren eines Java-Streams.

Schnittstelle in Java

Syntax

StromStrom;

Hier ist T je nach Deklaration entweder ein Klassenobjekt oder ein Datentyp.

Java-Stream-Funktionen

Die Funktionen von Java-Streams sind unten aufgeführt:

• Ein Stream ist keine Datenstruktur; Es werden lediglich Eingaben von Collections-Arrays oder I/O-Kanälen entgegengenommen.
• Streams verändern die Originaldaten nicht; Sie produzieren nur mit ihren Methoden Ergebnisse.
• Zwischenoperationen (wie Filterzuordnung usw.) sind verzögert und geben einen anderen Stream zurück, sodass Sie sie miteinander verketten können.
• Eine Terminaloperation (wie „Collect forEach Count“) beendet den Stream und gibt das Endergebnis aus.

Verschiedene Vorgänge auf Streams

Es gibt zwei Arten von Operationen in Streams:

1. Zwischenoperationen
2. Terminalbetrieb

Zwischenoperationen

Zwischenoperationen sind Operationstypen, bei denen mehrere Methoden hintereinander verkettet werden.

Merkmale von Zwischenoperationen

• Methoden sind miteinander verkettet.
• Zwischenoperationen wandeln einen Stream in einen anderen Stream um.
• Es ermöglicht das Filterkonzept, bei dem eine Methode Daten filtert und sie nach der Verarbeitung an eine andere Methode übergibt.

Wichtige Zwischenoperationen

Nachfolgend sind einige Zwischenoperationen aufgeführt:

1. Karte() : Die Map-Methode wird verwendet, um einen Stream zurückzugeben, der aus den Ergebnissen der Anwendung der angegebenen Funktion auf die Elemente dieses Streams besteht.

Syntax:

StromKarte(FunktionMapper)

2. filter() : Die Filtermethode wird verwendet, um Elemente gemäß dem als Argument übergebenen Prädikat auszuwählen.

Syntax:

Stromfilter(PrädikatPrädikat)

3. sortiert() : Die sortierte Methode wird zum Sortieren des Streams verwendet.

Syntax:

Stromsortiert()
Stromsortiert(KomparatorKomparator)

4. flatMap(): Die flatMap-Operation in Java Streams wird verwendet, um einen Stream von Sammlungen in einen einzelnen Stream von Elementen zu reduzieren.

Syntax:

StromflatMap(Funktion> Mapper)

5. eindeutig() : Entfernt doppelte Elemente. Es gibt einen Stream zurück, der aus den unterschiedlichen Elementen besteht (gemäß Object.equals(Object)).

Syntax:

Stromunterscheidbar()

6. peek() : Führt eine Aktion für jedes Element aus, ohne den Stream zu ändern. Es gibt einen Stream zurück, der aus den Elementen dieses Streams besteht und zusätzlich die bereitgestellte Aktion für jedes Element ausführt, während Elemente aus dem resultierenden Stream verbraucht werden.

Syntax:

schönstes Lächeln

Strompeek(VerbraucherAktion)

Java-Programm, das die Verwendung aller Zwischenoperationen demonstriert:

import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.stream.Collectors; public class StreamIntermediateOperationsExample {  public static void main(String[] args) {  // List of lists of names  List<List<String>> listOfLists = Arrays.asList(  Arrays.asList('Reflection' 'Collection' 'Stream')  Arrays.asList('Structure' 'State' 'Flow')  Arrays.asList('Sorting' 'Mapping' 'Reduction' 'Stream')  );  // Create a set to hold intermediate results  Set<String> intermediateResults = new HashSet<>();  // Stream pipeline demonstrating various intermediate operations  List<String> result = listOfLists.stream()  .flatMap(List::stream)   .filter(s -> s.startsWith('S'))   .map(String::toUpperCase)   .distinct()   .sorted()   .peek(s -> intermediateResults.add(s))  .collect(Collectors.toList());   // Print the intermediate results  System.out.println('Intermediate Results:');  intermediateResults.forEach(System.out::println);  // Print the final result  System.out.println('Final Result:');  result.forEach(System.out::println);  } } 

Intermediate Results: STRUCTURE STREAM STATE SORTING Final Result: SORTING STATE STREAM STRUCTURE 

Erläuterung:

• Die listOfLists wird als Liste erstellt, die andere Listen mit Zeichenfolgen enthält.
• flatMap(Liste::stream): Reduziert die verschachtelten Listen in einen einzigen Zeichenfolgenstrom.
• filter(s -> s.startsWith('S')) : Filtert die Zeichenfolgen so, dass nur diejenigen enthalten sind, die mit „S“ beginnen.
• map(String::toUpperCase) : Konvertiert jede Zeichenfolge im Stream in Großbuchstaben.
• unterscheidbar() : Entfernt alle doppelten Zeichenfolgen.
• sortiert() : Sortiert die resultierenden Zeichenfolgen alphabetisch.
• spähen(...): Fügt jedes verarbeitete Element zur Zwischenprüfung zum Satz „intermediateResults“ hinzu.
• sammeln(Collectors.toList()): Sammelt die endgültig verarbeiteten Zeichenfolgen in einer Liste mit dem Namen „Ergebnis“.

Das Programm gibt die Zwischenergebnisse aus, die im Satz „intermediateResults“ gespeichert sind. Abschließend wird die Ergebnisliste gedruckt, die die vollständig verarbeiteten Zeichenfolgen nach allen Stream-Operationen enthält.

Terminalbetrieb

Terminaloperationen sind die Art von Operationen, die das Ergebnis zurückgeben. Diese Vorgänge werden nicht weiter verarbeitet, sondern geben lediglich einen Endergebniswert zurück.

Wichtige Terminaloperationen

1. sammeln() : Die Collect-Methode wird verwendet, um das Ergebnis der am Stream durchgeführten Zwischenoperationen zurückzugeben.

Syntax:

R sammeln(CollectorKollektor)

2. forEach() : Die forEach-Methode wird verwendet, um jedes Element des Streams zu durchlaufen.

Syntax:

void forEach(ConsumerAktion)

3. Reduzieren(): Die Methode „reduce“ wird verwendet, um die Elemente eines Streams auf einen einzigen Wert zu reduzieren. Die Reduce-Methode benötigt einen BinaryOperator als Parameter.

Syntax:

T Reduce(T Identität BinaryOperatorAkkumulator)
Optionalreduzieren(BinaryOperatorAkkumulator)

4. count() : Gibt die Anzahl der Elemente im Stream zurück.

Syntax:

lange Zählung()

5. findFirst() : Gibt das erste Element des Streams zurück, falls vorhanden.

Syntax:

OptionalfindFirst()

SQL auswählen als

6. allMatch() : Prüft, ob alle Elemente des Streams mit einem bestimmten Prädikat übereinstimmen.

Syntax:

boolean allMatch(PredicatePrädikat)

7. Anymatch () : Prüft, ob ein Element des Streams mit einem bestimmten Prädikat übereinstimmt.

Syntax:

Boolean Anymatch (PrädikatPrädikat)

Hier wird der Variablen ans 0 als Anfangswert zugewiesen und i dazu addiert.

Notiz: Zwischenoperationen basieren auf dem Konzept der Lazy Evaluation, das sicherstellt, dass jede Methode einen festen Wert (Terminaloperation) zurückgibt, bevor zur nächsten Methode übergegangen wird.

Java-Programm, das alle Terminaloperationen nutzt:

import java.util.*; import java.util.stream.Collectors; public class StreamTerminalOperationsExample {  public static void main(String[] args) {  // Sample data  List<String> names = Arrays.asList(  'Reflection' 'Collection' 'Stream'  'Structure' 'Sorting' 'State'  );  // forEach: Print each name  System.out.println('forEach:');  names.stream().forEach(System.out::println);  // collect: Collect names starting with 'S' into a list  List<String> sNames = names.stream()  .filter(name -> name.startsWith('S'))  .collect(Collectors.toList());  System.out.println('ncollect (names starting with 'S'):');  sNames.forEach(System.out::println);  // reduce: Concatenate all names into a single string  String concatenatedNames = names.stream().reduce(  ''  (partialString element) -> partialString + ' ' + element  );  System.out.println('nreduce (concatenated names):');  System.out.println(concatenatedNames.trim());  // count: Count the number of names  long count = names.stream().count();  System.out.println('ncount:');  System.out.println(count);  // findFirst: Find the first name  Optional<String> firstName = names.stream().findFirst();  System.out.println('nfindFirst:');  firstName.ifPresent(System.out::println);  // allMatch: Check if all names start with 'S'  boolean allStartWithS = names.stream().allMatch(  name -> name.startsWith('S')  );  System.out.println('nallMatch (all start with 'S'):');  System.out.println(allStartWithS);  // anyMatch: Check if any name starts with 'S'  boolean anyStartWithS = names.stream().anyMatch(  name -> name.startsWith('S')  );  System.out.println('nanyMatch (any start with 'S'):');  System.out.println(anyStartWithS);  } } 

Ausgabe:

Erläuterung:

• Die Namensliste wird mit Beispielzeichenfolgen erstellt.
• forEach: Druckt jeden Namen in der Liste.
• sammeln : Filtert Namen, die mit „S“ beginnen, und sammelt sie in einer neuen Liste.
• reduzieren : Verkettet alle Namen zu einer einzigen Zeichenfolge.
• zählen : Zählt die Gesamtzahl der Namen.
• findFirst : Sucht und druckt den ersten Namen in der Liste.
• allMatch : Prüft, ob alle Namen mit „S“ beginnen.
• unglücklich : Prüft, ob ein Name mit „S“ beginnt.

Das Programm gibt jeden Namen aus, der mit „S“ beginnt. Verkettete Namen, die Anzahl der Namen, den Vornamen, ob alle Namen mit „S“ beginnen und ob ein Name mit „S“ beginnt.

Nutzen von Java Stream

Es gibt einige Vorteile, aufgrund derer wir Stream in Java verwenden, wie unten erwähnt:

• Keine Lagerung
• Pipeline von Funktionen
• Faulheit
• Kann unendlich sein
• Kann parallelisiert werden
• Kann aus Sammlungen, Arrays, Dateien, Zeilen, Methoden in Stream, IntStream usw. erstellt werden.

Reale Anwendungsfälle von Java Streams

Streams werden in modernen Java-Anwendungen häufig verwendet für:

• Datenverarbeitung
• Zur Verarbeitung von JSON/XML-Antworten
• Für Datenbankoperationen
• Gleichzeitige Verarbeitung