STRAUMĒJIET JAVA VALODĀ

Straume tika ieviesta Java 8 Stream API tiek izmantots, lai apstrādātu objektu kolekcijas. Java straume ir objektu secība, kas atbalsta dažādas metodes, kuras var konveijezēt, lai iegūtu vēlamo rezultātu.

Straumes izmantošana Java

Straumes lietojumi Java ir minēti tālāk:

Straumes API ir veids, kā izteikt un apstrādāt objektu kolekcijas.
Ļaujiet mums veikt tādas darbības kā filtrēšanas kartēšanas samazināšana un kārtošana.

Kā izveidot Java straumi

Java straumes izveide ir viens no visvienkāršākajiem soļiem pirms Java Stream funkcionalitātes apsvēršanas. Tālāk ir norādīta Java straumes deklarēšanas sintakse.

Sintakse

Straume straume;

Šeit T ir vai nu klases objekts, vai datu tips atkarībā no deklarācijas.

Java straumes līdzekļi

Java straumju funkcijas ir minētas tālāk:

Straume nav datu struktūra; tas aizņem tikai ievadi no kolekciju masīviem vai I/O kanāliem.
Straumes nemaina sākotnējos datus; viņi tikai rada rezultātus, izmantojot savas metodes.
Starpposma darbības (piemēram, filtru karte utt.) ir slinkas un atgriež citu straumi, lai jūs varētu tās savienot kopā.
Termināla darbība (piemēram, apkopot par katru skaitu) pabeidz straumi un sniedz gala rezultātu.

Dažādas darbības straumēs

Straumēs ir divu veidu darbības:

Starpposma operācijas
Termināļa darbības

Starpposma operācijas

Java straumes operācijas

Starpposma operācijas ir operāciju veidi, kuros vairākas metodes ir sasaistītas pēc kārtas.

Starpposma darbību raksturojums

Metodes ir savienotas kopā.
Starpposma darbības pārveido straumi citā straumē.
Tas nodrošina filtrēšanas koncepciju, kad viena metode filtrē datus un pēc apstrādes nodod to citai metodei.

Svarīgas starpposma darbības

Tālāk ir minētas dažas starpposma darbības:

1. karte() : Kartes metode tiek izmantota, lai atgrieztu straumi, kas sastāv no dotās funkcijas piemērošanas rezultātiem šīs straumes elementiem.

Sintakse:

Straume karte (Funkcija kartētājs)

2. filtrs() : filtra metode tiek izmantota, lai atlasītu elementus atbilstoši predikātam, kas nodots kā arguments.

Sintakse:

Straume filtrs (predikāts predikāts)

3. sakārtots() : straumes kārtošanai tiek izmantota šķirošanas metode.

Sintakse:

Straume sakārtots()
Straume sakārtots (Salīdzinātājs salīdzinājums)

4. flatMap(): FlatMap operācija Java straumēs tiek izmantota, lai saplacinātu kolekciju straumi vienā elementu plūsmā.

Sintakse:

Straume flatMap (Funkcija > kartētājs)

5. atšķirīgs() : noņem dublētos elementus. Tas atgriež straumi, kas sastāv no atsevišķiem elementiem (saskaņā ar Object.equals(Object)).

Sintakse:

Straume atšķirīgs ()

6. palūrēt() : veic darbību ar katru elementu, nemainot straumi. Tas atgriež straumi, kas sastāv no šīs straumes elementiem, papildus veicot norādīto darbību katram elementam, jo elementi tiek patērēti no iegūtās straumes.

Sintakse:

Straume palūrēt (Patērētājs darbība)

Java programma, kas demonstrē visu starpposma darbību izmantošanu:

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

Izvade

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

Paskaidrojums:

ListOfLists tiek izveidots kā saraksts, kurā ir citi virkņu saraksti.
flatMap (saraksts::straume): Saplacina ligzdotos sarakstus vienā virkņu straumē.
filtrs(s -> s.startsWith('S')) : filtrē virknes, iekļaujot tikai tās, kas sākas ar "S".
karte (String::UpperCase) : pārvērš katru virkni straumē par lielajiem burtiem.
atšķirīgs () : noņem visas dublētās virknes.
sakārtots() : sakārto iegūtās virknes alfabētiskā secībā.
palūrēt (...): Katru apstrādāto elementu pievieno starpposma pārbaudei starprezultātu kopai.
savākt(Collectors.toList()): Apkopo galīgās apstrādātās virknes sarakstā, ko sauc par rezultātu.

Programma izdrukā starprezultātus, kas saglabāti intermediateResults komplektā. Visbeidzot, pēc visām straumes darbībām tiek izdrukāts rezultātu saraksts, kurā ir pilnībā apstrādātas virknes.

Termināļa darbības

Termināļa darbības ir operāciju veids, kas atgriež rezultātu. Šīs darbības netiek tālāk apstrādātas, tikai atgriež gala rezultāta vērtību.

Svarīgas termināļa darbības

1. savākt() : apkopošanas metode tiek izmantota, lai atgrieztu straumē veikto starpoperāciju rezultātu.

Sintakse:

R savākt (Kolekcionārs kolekcionārs)

2. katram() : ForEach metode tiek izmantota, lai atkārtotu katru straumes elementu.

Sintakse:

spēkā neesošs par katru (patērētājs darbība)

3. samazināt(): Samazināšanas metodi izmanto, lai samazinātu straumes elementus līdz vienai vērtībai. Samazināšanas metode izmanto BinaryOperator kā parametru.

Sintakse:

T samazināt(T identitāte BinaryOperator akumulators)
Pēc izvēles samazināt (BinaryOperator akumulators)

4. count () : atgriež straumē esošo elementu skaitu.

Sintakse:

garš skaitīšana ()

5. FindFirst() : atgriež pirmo straumes elementu, ja tāds ir.

Sintakse:

Pēc izvēles atrast pirmo ()

6. allMatch() : pārbauda, vai visi straumes elementi atbilst noteiktajam predikātam.

Sintakse:

Būla allMatch(Predikāts predikāts)

7. Jebkurš mačs () : pārbauda, vai kāds straumes elements atbilst noteiktajam predikātam.

Sintakse:

Būla Anymatch (predikāts predikāts)

Šeit ans mainīgajam tiek piešķirta 0 kā sākotnējā vērtība, un tam tiek pievienots i.

Piezīme: Starpposma darbības darbojas, pamatojoties uz slinkās novērtēšanas koncepciju, kas nodrošina, ka katra metode atgriež fiksētu vērtību (termināla darbība) pirms pārejas uz nākamo metodi.

Java programma, kas izmanto visas termināļa darbības:

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

Izvade:

Izvade

Paskaidrojums:

Vārdu saraksts tiek izveidots ar virkņu paraugiem.
katram: Drukā katru nosaukumu sarakstā.
savākt : filtrē vārdus, kas sākas ar “S”, un apkopo tos jaunā sarakstā.
samazināt : apvieno visus nosaukumus vienā virknē.
skaitīt : saskaita kopējo vārdu skaitu.
atrast Vispirms : atrod un izdrukā pirmo vārdu sarakstā.
allMatch : pārbauda, vai visi vārdi sākas ar "S".
neveiksminieks : pārbauda, vai kāds nosaukums sākas ar "S".

Programma izdrukā katra vārda nosaukumus, kas sākas ar "S", sasaistītus nosaukumus vārdu skaitu, vārdu skaitu, vai visi vārdi sākas ar "S" un vai kāds vārds sākas ar "S".

Java Stream priekšrocības

Ir dažas priekšrocības, kuru dēļ mēs izmantojam straumi Java, kā minēts tālāk:

Nav krātuves
Funkciju cauruļvads
Slinkums
Var būt bezgalīgs
Var paralēlizēt
Var izveidot no kolekciju masīviem Faili Līnijas Metodes programmā Stream IntStream utt.