STROOM IN JAVA

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.

Syntaxis

Stroom stroom;

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:

Tussenliggende operaties
Terminaloperaties

Tussenliggende operaties

Java Stream-bewerkingen

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:

Stroom kaart(Functie kaartmaker)

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

Syntaxis:

Stroom filter(Predikaat predikaat)

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

Syntaxis:

Stroom gesorteerd()
Stroom gesorteerd(vergelijker comparator)

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

Syntaxis:

Stroom flatMap(Functie > kaartmaker)

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

Syntaxis:

Stroom verschillend()

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:

Stroom kijkje (Consument actie)

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

Java

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

Uitvoer

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(Verzamelaar verzamelaar)

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

Syntaxis:

void forEach(Consument actie)

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 BinaryOperator accumulator)
Optioneel reduce(BinaireOperator accumulator)

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

Syntaxis:

lange telling()

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

Syntaxis:

Optioneel vindEerste()

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

Syntaxis:

boolean allMatch(Predicaat predikaat)

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

Syntaxis:

Booleaanse Anymatch (Predikaat predikaat)

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:

Java

    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:

Uitvoer

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.