STREAM ÎN JAVA

Stream a fost introdus în Java 8 API-ul Stream este folosit pentru a procesa colecții de obiecte. Un flux în Java este o secvență de obiecte care acceptă diverse metode care pot fi canalizate pentru a produce rezultatul dorit.

Utilizarea Stream în Java

Utilizările Stream în Java sunt menționate mai jos:

Stream API este o modalitate de a exprima și procesa colecții de obiecte.
Permiteți-ne să efectuăm operațiuni precum filtrarea, reducerea și sortarea cartografierii.

Cum se creează un flux Java

Crearea Java Stream este unul dintre cei mai de bază pași înainte de a lua în considerare funcționalitățile Java Stream. Mai jos este sintaxa dată pentru declararea unui flux Java.

Sintaxă

Flux pârâul;

Aici T este fie un obiect de clasă, fie un tip de date, în funcție de declarație.

Caracteristici Java Stream

Caracteristicile fluxurilor Java sunt menționate mai jos:

Un flux nu este o structură de date; preia doar intrare de la Collections Arrays sau canale I/O.
Fluxurile nu modifică datele originale; produc rezultate numai folosind metodele lor.
Operațiunile intermediare (cum ar fi harta de filtrare etc.) sunt leneșe și returnează un alt flux, astfel încât să le puteți lega împreună.
O operație terminală (cum ar fi colectarea pentru fiecare numărare) încheie fluxul și dă rezultatul final.

Operații diferite pe fluxuri

Există două tipuri de operațiuni în fluxuri:

Operațiuni intermediare
Operațiuni terminale

Operațiuni intermediare

Operațiuni Java Stream

Operațiile intermediare sunt tipurile de operații în care mai multe metode sunt înlănțuite într-un rând.

Caracteristicile operațiunilor intermediare

Metodele sunt legate între ele.
Operațiunile intermediare transformă un flux într-un alt flux.
Activează conceptul de filtrare în care o metodă filtrează datele și le transmite unei alte metode după procesare.

Operațiuni intermediare importante

Există câteva operațiuni intermediare menționate mai jos:

1. harta() : Metoda map este folosită pentru a returna un flux constând din rezultatele aplicării funcției date la elementele acestui flux.

Sintaxă:

Flux harta (Funcția cartograf)

2. filtru () : Metoda de filtrare este folosită pentru a selecta elemente conform Predicatului transmis ca argument.

Sintaxă:

Flux filtru (predicat predicat)

3. sortat() : Metoda sortată este utilizată pentru a sorta fluxul.

Sintaxă:

Flux sortat()
Flux sortat(Comparator comparator)

4. flatMap(): Operația flatMap din Java Streams este folosită pentru a aplatiza un flux de colecții într-un singur flux de elemente.

Sintaxă:

Flux flatMap (Funcția > cartografiere)

5. distinct() : elimină elementele duplicat. Returnează un flux format din elemente distincte (conform Object.equals(Object)).

Sintaxă:

Flux distinct()

6. privirea() : Efectuează o acțiune asupra fiecărui element fără a modifica fluxul. Returnează un flux format din elementele acestui flux, efectuând suplimentar acțiunea furnizată asupra fiecărui element, deoarece elementele sunt consumate din fluxul rezultat.

Sintaxă:

Flux peek(Consumator acţiune)

Program Java care demonstrează utilizarea tuturor operațiilor intermediare:

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

Ieșire

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

Explicaţie:

ListOfLists este creată ca o listă care conține alte liste de șiruri.
flatMap(Lista::stream): Aplatizează listele imbricate într-un singur flux de șiruri.
filtru (e -> s.startsWith('S')) : filtrează șirurile pentru a le include numai pe cele care încep cu „S”.
map(String::toUpperCase) : convertește fiecare șir din flux în majuscule.
distinct() : elimină orice șiruri duplicate.
sortat() : Sortează șirurile rezultate în ordine alfabetică.
arunca o privire(...): Adaugă fiecare element procesat la setul intermediateResults pentru inspecția intermediară.
colectează(Collectors.toList()): Colectează șirurile finale procesate într-o listă numită rezultat.

Programul imprimă rezultatele intermediare stocate în setul intermediateResults. În cele din urmă, tipărește lista de rezultate care conține șirurile complet procesate după toate operațiunile de flux.

Operațiuni terminale

Operațiile terminale sunt tipul de operații care returnează rezultatul. Aceste Operații nu sunt procesate în continuare, ci doar returnează o valoare finală a rezultatului.

Operațiuni importante ale terminalului

1. colecta() : Metoda de colectare este utilizată pentru a returna rezultatul operațiunilor intermediare efectuate pe flux.

Sintaxă:

R colecta(Colector colector)

2. pentru fiecare() : Metoda forEach este folosită pentru a itera prin fiecare element al fluxului.

Sintaxă:

nul pentru fiecare (Consumator acţiune)

3. reduce(): Metoda reducere este utilizată pentru a reduce elementele unui flux la o singură valoare. Metoda reduce ia ca parametru un BinaryOperator.

Sintaxă:

T reduce(T identitate BinaryOperator acumulator)
Opțional reduce(BinaryOperator acumulator)

4. numără() : returnează numărul de elemente din flux.

Sintaxă:

număr lung ()

5. findFirst() : Returnează primul element al fluxului, dacă este prezent.

Sintaxă:

Opțional findFirst()

6. allMatch() : verifică dacă toate elementele fluxului se potrivesc cu un anumit predicat.

Sintaxă:

boolean allMatch(Predicat predicat)

7. Orice potrivire () : Verifică dacă vreun element al fluxului se potrivește cu un anumit predicat.

Sintaxă:

Boolean Anymatch (predicat predicat)

Aici unei variabile i se atribuie 0 ca valoare inițială și i se adaugă la aceasta.

Nota: Operațiunile intermediare rulează pe baza conceptului de evaluare lenenă, care asigură că fiecare metodă returnează o valoare fixă (operație terminală) înainte de a trece la următoarea metodă.

Program Java care utilizează toate operațiunile terminalului:

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

Ieșire:

Ieșire

Explicaţie:

Lista de nume este creată cu șiruri de exemplu.
pentru fiecare: Tipărește fiecare nume din listă.
colecta : filtrează numele care încep cu „S” și le adună într-o nouă listă.
reduce : Concatenează toate numele într-un singur șir.
conta : numără numărul total de nume.
găsi în primul rând : Găsește și tipărește prenumele din listă.
allMatch : Verifică dacă toate numele încep cu „S”.
ghinionist : Verifică dacă orice nume începe cu „S”.

Programul imprimă fiecare nume nume care încep cu „S” nume concatenate numărul de nume prenumele dacă toate numele încep cu „S” și dacă orice nume începe cu „S”.

Beneficiul Java Stream

Există câteva beneficii din cauza cărora folosim Stream în Java, așa cum este menționat mai jos:

Fără depozitare
Conducta de funcții
Lene
Poate fi infinit
Poate fi paralelizat
Poate fi creat din matrice de colecții Fișiere Linii Metode în Stream IntStream etc.