Stream werd geïntroduceerd in Java 8 de Stream API wordt gebruikt om verzamelingen objecten te verwerken. Een stream in Java is een reeks objecten die verschillende methoden ondersteunen die kunnen worden gepijplijnd om het gewenste resultaat te produceren. 

Gebruik van Stream in Java

De toepassingen van Stream in Java worden hieronder vermeld:

• Stream API is een manier om verzamelingen objecten uit te drukken en te verwerken.
• Stel ons in staat om bewerkingen uit te voeren zoals het filteren van kaarten, het verkleinen en sorteren.

Hoe u een Java-stream maakt

Java Stream Creatie is een van de meest fundamentele stappen voordat u de functionaliteiten van de Java Stream in overweging neemt. Hieronder vindt u de syntaxis voor het declareren van een Java-stream.

arrayreeks in c

Syntaxis

Stroomstroom;

Hier is T een klassenobject of een gegevenstype, afhankelijk van de declaratie.

Java Stream-functies

De kenmerken van Java-streams worden hieronder vermeld:

• Een stream is geen datastructuur; er is alleen input nodig van Collections Arrays of I/O-kanalen.
• Streams wijzigen de originele gegevens niet; ze produceren alleen resultaten met behulp van hun methoden.
• Tussenliggende bewerkingen (zoals een filterkaart enz.) zijn lui en retourneren een andere stream, zodat u ze aan elkaar kunt koppelen.
• Een terminalbewerking (zoals collect forEach count) beëindigt de stream en geeft het eindresultaat.

Verschillende bewerkingen op streams

Er zijn twee soorten bewerkingen in streams:

1. Tussenliggende operaties
2. Terminaloperaties

Tussenliggende operaties

Tussenliggende bewerkingen zijn het soort bewerkingen waarbij meerdere methoden achter elkaar worden geketend.

Kenmerken van tussentijdse operaties

• Methoden zijn aan elkaar gekoppeld.
• Tussenliggende bewerkingen transformeren een stroom in een andere stroom.
• Het maakt het concept van filteren mogelijk, waarbij de ene methode gegevens filtert en deze na verwerking doorgeeft aan een andere methode.

Belangrijke tussentijdse operaties

Hieronder worden een aantal tussenliggende bewerkingen genoemd:

1. kaart() : De kaartmethode wordt gebruikt om een ​​stroom terug te geven die bestaat uit de resultaten van het toepassen van de gegeven functie op de elementen van deze stroom.

Syntaxis:

Stroomkaart(Functiekaartmaker)

2. filter() : De filtermethode wordt gebruikt om elementen te selecteren volgens het predikaat dat als argument is doorgegeven.

Syntaxis:

Stroomfilter(Predikaatpredikaat)

3. gesorteerd() : De gesorteerde methode wordt gebruikt om de stream te sorteren.

Syntaxis:

Stroomgesorteerd()
Stroomgesorteerd(vergelijkercomparator)

4. flatMap(): De flatMap-bewerking in Java Streams wordt gebruikt om een ​​stroom verzamelingen af ​​te vlakken tot één enkele stroom elementen.

Syntaxis:

StroomflatMap(Functie> kaartmaker)

5. onderscheidend() : Verwijdert dubbele elementen. Het retourneert een stroom die bestaat uit de afzonderlijke elementen (volgens Object.equals(Object)).

Syntaxis:

Stroomverschillend()

6. kijk() : Voert een actie uit op elk element zonder de stream te wijzigen. Het retourneert een stroom die bestaat uit de elementen van deze stroom en voert bovendien de opgegeven actie uit op elk element terwijl elementen uit de resulterende stroom worden verbruikt.

Syntaxis:

Stroomkijkje (Consumentactie)

Java-programma dat het gebruik van alle tussenliggende bewerkingen demonstreert:

cijfers voor het alfabet

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 

Uitleg:

• De listOfLists wordt gemaakt als een lijst met andere lijsten met tekenreeksen.
• flatMap(Lijst::stream): Maakt de geneste lijsten plat tot één enkele stroom tekenreeksen.
• filter(s -> s.startsWith('S')) : Filtert de tekenreeksen zodat alleen de tekenreeksen worden opgenomen die beginnen met 'S'.
• map(String::toUpperCase) : Converteert elke tekenreeks in de stream naar hoofdletters.
• verschillend() : Verwijdert eventuele dubbele tekenreeksen.
• gesorteerd() : Sorteert de resulterende tekenreeksen alfabetisch.
• kijkje(...): Voegt elk verwerkt element toe aan de set intermediateResults voor tussentijdse inspectie.
• collect(Verzamelaars.toLijst()): Verzamelt de uiteindelijk verwerkte tekenreeksen in een lijst met de naam resultaat.

Het programma drukt de tussenresultaten af ​​die zijn opgeslagen in de set intermediateResults. Ten slotte drukt het de resultatenlijst af die de volledig verwerkte strings bevat na alle streambewerkingen.

Terminaloperaties

Terminalbewerkingen zijn het type bewerkingen dat het resultaat oplevert. Deze bewerkingen worden niet verder verwerkt en retourneren alleen een uiteindelijke resultaatwaarde.

Belangrijke terminaloperaties

1. verzamelen() : De collect-methode wordt gebruikt om het resultaat te retourneren van de tussentijdse bewerkingen die op de stream zijn uitgevoerd.

Syntaxis:

R verzamelen(Verzamelaarverzamelaar)

2. voorElke() : De forEach-methode wordt gebruikt om elk element van de stream te doorlopen.

Syntaxis:

void forEach(Consumentactie)

3. verminderen(): De reduce-methode wordt gebruikt om de elementen van een stream tot één enkele waarde te reduceren. De reduce-methode heeft een BinaryOperator als parameter.

Syntaxis:

T reduce(T identiteit BinaryOperatoraccumulator)
Optioneelreduce(BinaireOperatoraccumulator)

4. tellen() : Retourneert het aantal elementen in de stream.

Syntaxis:

lange telling()

5. vindEerste() : Retourneert het eerste element van de stream, indien aanwezig.

Syntaxis:

OptioneelvindEerste()

ipconfig voor ubuntu

6. allMatch() : Controleert of alle elementen van de stream overeenkomen met een bepaald predikaat.

Syntaxis:

boolean allMatch(Predicaatpredikaat)

7. Elke match () : Controleert of een element van de stream overeenkomt met een bepaald predikaat.

Syntaxis:

Booleaanse Anymatch (Predikaatpredikaat)

Hier wordt aan de ans-variabele de beginwaarde 0 toegewezen en wordt er i aan toegevoegd.

Opmerking: Tussenliggende bewerkingen worden uitgevoerd op basis van het concept van Lazy Evaluation, dat ervoor zorgt dat elke methode een vaste waarde retourneert (terminalbewerking) voordat naar de volgende methode wordt overgegaan.

Java-programma dat alle terminalbewerkingen gebruikt:

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

Uitgang:

Uitleg:

• De namenlijst wordt gemaakt met voorbeeldreeksen.
• voorElk: Drukt elke naam in de lijst af.
• verzamelen : Filtert namen die beginnen met 'S' en verzamelt ze in een nieuwe lijst.
• verminderen : voegt alle namen samen tot één enkele tekenreeks.
• graaf : Telt het totale aantal namen.
• vindEerste : Zoekt de voornaam in de lijst en drukt deze af.
• allesMatch : Controleert of alle namen beginnen met 'S'.
• pech : Controleert of een naam begint met 'S'.

Het programma drukt elke naam af, namen die beginnen met 'S', aaneengeschakelde namen, het aantal namen, de voornaam, of alle namen beginnen met 'S' en of een naam begint met 'S'.

Voordeel van Java Stream

Er zijn enkele voordelen waardoor we Stream in Java gebruiken, zoals hieronder vermeld:

• Geen opslag
• Pijplijn van functies
• Luiheid
• Kan oneindig zijn
• Kan worden geparallelliseerd
• Kan worden gemaakt op basis van verzamelingen matrices Bestanden Lijnen Methoden in Stream IntStream enz.

Real-World gebruiksscenario's van Java-streams

Streams worden veel gebruikt in moderne Java-toepassingen voor:

• Gegevensverwerking
• Voor het verwerken van JSON/XML-antwoorden
• Voor databasebewerkingen
• Gelijktijdige verwerking