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ó.

karakterlánc formátum

Szintaxis

Folyamfolyam;

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:

Folyamté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:

Folyamfilter(Predikátumállítmány)

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

Szintaxis:

Folyamrendezve()
Folyamrendezve(Ö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:

FolyamflatMap (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:

Folyamkü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:

Folyamkukucská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(Collectorgyűjtő)

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

Szintaxis:

érvénytelen forEach(Fogyasztóakció)

javascript onclick

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 BinaryOperatorakkumulátor)
Választhatócsökkenti(BinaryOperatorakkumulá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()

válasszon többtáblás sql-t

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