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.

lungimea șirului java

Sintaxă

Fluxpâ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:

1. Operațiuni intermediare
2. Operațiuni terminale

Operațiuni intermediare

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ă:

Fluxharta (Funcțiacartograf)

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

Sintaxă:

Fluxfiltru (predicatpredicat)

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

Sintaxă:

Fluxsortat()
Fluxsortat(Comparatorcomparator)

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ă:

FluxflatMap (Funcția> cartografiere)

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

șir în format java

Sintaxă:

Fluxdistinct()

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ă:

Fluxpeek(Consumatoracţiune)

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

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 

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(Colectorcolector)

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

Sintaxă:

nul pentru fiecare (Consumatoracţ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 BinaryOperatoracumulator)
Opționalreduce(BinaryOperatoracumulator)

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ționalfindFirst()

do while loop în java

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

Sintaxă:

boolean allMatch(Predicatpredicat)

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

Sintaxă:

Boolean Anymatch (predicatpredicat)

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:

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:

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.

Cazuri de utilizare în lumea reală a fluxurilor Java

Fluxurile sunt utilizate pe scară largă în aplicațiile Java moderne pentru:

• Prelucrarea datelor
• Pentru procesarea răspunsurilor JSON/XML
• Pentru operațiuni cu baze de date
• Procesare concomitentă