A Stream bevezetésre került Java 8 a Stream API objektumgyűjtemények feldolgozására szolgál. A Java-folyamok olyan objektumok sorozata, amelyek támogatják a különböző metódusokat, amelyek a kívánt eredmény elérése érdekében folyamatba állíthatók. 

A Stream használata Java nyelven

A Stream Java-ban való felhasználását az alábbiakban ismertetjük:

• A Stream API az objektumgyűjtemények kifejezésének és feldolgozásának módja.
• Lehetővé teszi számunkra olyan műveletek végrehajtását, mint a szűrési leképezés csökkentése és rendezése.

Hogyan készítsünk Java adatfolyamot

A Java Stream létrehozása az egyik legalapvetőbb lépés, mielőtt megvizsgálná a Java Stream funkcióit. Az alábbiakban a Java adatfolyam deklarálásához megadott szintaxis látható.

Szintaxis

Folyam folyam;

Itt T egy osztályobjektum vagy adattípus a deklarációtól függően.

Java Stream funkciók

A Java adatfolyamok jellemzői az alábbiakban találhatók:

• Az adatfolyam nem adatstruktúra; csak a gyűjtemények tömbjeiről vagy az I/O csatornákról veszi a bemenetet.
• Az adatfolyamok nem módosítják az eredeti adatokat; csak módszereikkel hoznak eredményt.
• A közbenső műveletek (például szűrőtérkép stb.) lusták, és egy másik adatfolyamot adnak vissza, így összeláncolhatod őket.
• Egy terminálművelet (mint például a collection forEach count) leállítja az adatfolyamot, és megadja a végeredményt.

Különböző műveletek az adatfolyamokon

A Streamekben kétféle művelet létezik:

1. Köztes műveletek
2. Terminálműveletek

Köztes műveletek

A közbenső műveletek olyan típusú műveletek, amelyekben több metódus van egymás után láncolva.

Köztes műveletek jellemzői

• A módszerek össze vannak láncolva.
• A közbenső műveletek egy adatfolyamot egy másik adatfolyammá alakítanak át.
• Lehetővé teszi a szűrés koncepcióját, ahol az egyik módszer szűri az adatokat, és a feldolgozás után átadja egy másik metódusnak.

Fontos köztes műveletek

Az alábbiakban felsorolunk néhány köztes műveletet:

1. térkép() : A map metódus egy olyan adatfolyam visszaadására szolgál, amely az adott függvény alkalmazásának eredményeiből áll a folyam elemeire.

Szintaxis:

Folyam térkép (Funkció térképező)

2. filter() : A szűrőmódszert az argumentumként átadott predikátum szerinti elemek kiválasztására használják.

Szintaxis:

Folyam filter(Predikátum állítmány)

3. rendezve() : A szortírozott módszer a folyam rendezésére szolgál.

Szintaxis:

Folyam rendezve()
Folyam rendezve(Összehasonlító összehasonlító)

4. flatMap(): A Java Streams flatMap művelete a gyűjtemények folyamának egyetlen elemfolyammá történő egyesítésére szolgál.

Szintaxis:

Folyam flatMap (Funkció > térképező)

5. megkülönböztető() : Eltávolítja az ismétlődő elemeket. Egy olyan adatfolyamot ad vissza, amely a különböző elemekből áll (az Object.equals(Object) szerint).

Szintaxis:

Folyam különböző()

6. kukucskál() : Minden elemen végrehajt egy műveletet a folyam módosítása nélkül. Egy adatfolyamot ad vissza, amely ennek az adatfolyamnak az elemeiből áll, és emellett végrehajtja a megadott műveletet minden egyes elemen, amint a kapott adatfolyam elemei felhasználásra kerülnek.

Szintaxis:

Folyam kukucskál (Fogyasztó akció)

Java program, amely bemutatja az összes köztes művelet használatát:

   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  

Magyarázat:

• A listOfLists olyan listaként jön létre, amely egyéb karakterlánc-listákat tartalmaz.
• flatMap(Lista::folyam): A beágyazott listákat egyetlen karakterláncra simítja.
• filter(s -> s.startsWith('S')) : Szűri a karakterláncokat, hogy csak az „S” betűvel kezdődő karakterláncokat tartalmazza.
• térkép (karakterlánc::nagybetűig) : Az adatfolyam minden karakterláncát nagybetűssé alakítja.
• különböző() : Eltávolítja az ismétlődő karakterláncokat.
• rendezve() : A kapott karakterláncokat ábécé sorrendbe rendezi.
• kandikál(...): Minden feldolgozott elemet hozzáad az intermediateResults készlethez a közbenső ellenőrzéshez.
• gyűjt (Collectors.toList()): Összegyűjti a végső feldolgozott karakterláncokat egy eredmény nevű listába.

A program kiírja az intermediateResults készletben tárolt köztes eredményeket. Végül kinyomtatja az eredménylistát, amely az összes adatfolyam művelet után tartalmazza a teljesen feldolgozott karakterláncokat.

Terminálműveletek

A terminálműveletek azok a műveletek, amelyek az eredményt adják vissza. Ezeket a műveleteket nem dolgozzák fel tovább, csak a végeredmény értéket adják vissza.

Fontos terminálműveletek

1. gyűjt() : Az adatfolyamon végrehajtott közbenső műveletek eredményének visszaadására a collection metódus szolgál.

Szintaxis:

R collection(Collector gyűjtő)

2. forEach() : A forEach metódus az adatfolyam minden elemén való iterációra szolgál.

Szintaxis:

érvénytelen forEach(Fogyasztó akció)

3. redukál(): A redukciós módszerrel egy adatfolyam elemeit egyetlen értékre csökkentjük. A redukciós módszer egy BinaryOperatort vesz paraméterként.

Szintaxis:

T redukció(T identitás BinaryOperator akkumulátor)
Választható csökkenti(BinaryOperator akkumulátor)

4. count() : Az adatfolyamban lévő elemek számát adja vissza.

Szintaxis:

hosszú számolás ()

5. findFirst() : Az adatfolyam első elemét adja vissza, ha van.

Szintaxis:

Választható findFirst()

6. allMatch() : Ellenőrzi, hogy az adatfolyam minden eleme egyezik-e egy adott predikátummal.

Szintaxis:

logikai allMatch(Predikátum állítmány)

7. Anymatch () : Ellenőrzi, hogy az adatfolyam bármely eleme egyezik-e egy adott predikátummal.

Szintaxis:

Boolean Anymatch (Predikátum állítmány)

Itt az ans változóhoz 0-t rendelünk kezdeti értékként, és hozzáadjuk az i-t.

Jegyzet: A köztes műveletek a Lazy Evaluation koncepciója alapján futnak, amely biztosítja, hogy minden metódus fix értéket ad vissza (Terminális művelet), mielőtt a következő metódusra lépne.

Java program az összes terminálműveletet használva:

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

Kimenet:

Magyarázat:

• A névlista mintakarakterláncokkal jön létre.
• forEach: Minden nevet kinyomtat a listában.
• gyűjt : Szűri az „S” betűvel kezdődő neveket, és új listába gyűjti őket.
• csökkenteni : Az összes nevet egyetlen karakterláncba fűzi össze.
• gróf : Számolja a nevek teljes számát.
• FindFirst : Megkeresi és kinyomtatja a keresztnevet a listában.
• allMatch : Ellenőrzi, hogy minden név "S"-vel kezdődik-e.
• szerencsétlen : Ellenőrzi, hogy valamelyik név "S"-vel kezdődik-e.

A program kiírja az egyes neveket "S"-vel kezdődően, összefűzött neveket a nevek számát a keresztnevet, hogy minden név "S"-vel kezdődik-e, és bármely név "S"-vel kezdődik-e.

A Java Stream előnyei

Vannak bizonyos előnyök, amelyek miatt a Stream szolgáltatást Javaban használjuk, az alábbiak szerint:

• Nincs tárhely
• Funkciók csővezetéke
• Lustaság
• Végtelen lehet
• Párhuzamba állítható
• Létrehozható gyűjteménytömbökből Fájlok Sorok Metódusok a Stream IntStreamben stb.

Java adatfolyamok valós használati esetei

Az adatfolyamokat széles körben használják a modern Java alkalmazásokban:

• Adatfeldolgozás
• JSON/XML válaszok feldolgozásához
• Adatbázis műveletekhez
• Párhuzamos feldolgozás