Il flusso è stato introdotto in Giava8 l'API Stream viene utilizzata per elaborare raccolte di oggetti. Uno stream in Java è una sequenza di oggetti che supporta vari metodi che possono essere messi in pipeline per produrre il risultato desiderato. 

Utilizzo di Stream in Java

Gli usi di Stream in Java sono menzionati di seguito:

• L'API Stream è un modo per esprimere ed elaborare raccolte di oggetti.
• Consentici di eseguire operazioni come filtraggio, mappatura, riduzione e ordinamento.

Come creare un flusso Java

La creazione di Java Stream è uno dei passaggi più basilari prima di considerare le funzionalità di Java Stream. Di seguito è riportata la sintassi fornita per dichiarare un Java Stream.

sommatore sommatore completo

Sintassi

Flussoflusso;

Qui T è un oggetto di classe o un tipo di dati a seconda della dichiarazione.

Funzionalità del flusso Java

Le funzionalità dei flussi Java sono menzionate di seguito:

• Uno stream non è una struttura dati; richiede solo l'input dagli array di raccolte o dai canali I/O.
• I flussi non modificano i dati originali; producono risultati solo utilizzando i loro metodi.
• Le operazioni intermedie (come la mappa dei filtri ecc.) sono pigre e restituiscono un altro flusso in modo da poterle concatenare insieme.
• Un'operazione terminale (come Collect forEach count) termina il flusso e fornisce il risultato finale.

Diverse operazioni sui flussi

Esistono due tipi di operazioni negli stream:

1. Operazioni intermedie
2. Operazioni sui terminali

Operazioni intermedie

Le operazioni intermedie sono i tipi di operazioni in cui più metodi sono concatenati in una riga.

Caratteristiche delle operazioni intermedie

• I metodi sono concatenati insieme.
• Le operazioni intermedie trasformano un flusso in un altro flusso.
• Abilita il concetto di filtraggio in cui un metodo filtra i dati e li passa a un altro metodo dopo l'elaborazione.

Importanti operazioni intermedie

Ci sono alcune operazioni intermedie menzionate di seguito:

1. mappa() : Il metodo map viene utilizzato per restituire un flusso costituito dai risultati dell'applicazione della funzione data agli elementi di questo flusso.

Sintassi:

Flussomappa(Funzionemappatore)

2. filtro() : Il metodo filter viene utilizzato per selezionare gli elementi secondo il predicato passato come argomento.

Sintassi:

Flussofiltro(Predicatopredicato)

3. ordinato() : il metodo sorted viene utilizzato per ordinare il flusso.

Sintassi:

Flussoordinato()
Flussoordinato(Comparatorecomparatore)

4. flatMap(): L'operazione flatMap in Java Streams viene utilizzata per appiattire un flusso di raccolte in un singolo flusso di elementi.

Sintassi:

FlussoflatMap(Funzione> mappatore)

5. distinto() : rimuove gli elementi duplicati. Restituisce un flusso costituito dagli elementi distinti (secondo Object.equals(Object)).

Sintassi:

Flussodistinto()

interruttore C#

6. sbirciatina() : esegue un'azione su ciascun elemento senza modificare lo stream. Restituisce un flusso costituito dagli elementi di questo flusso eseguendo inoltre l'azione fornita su ciascun elemento man mano che gli elementi vengono consumati dal flusso risultante.

Sintassi:

Flussosbirciare(Consumatoreazione)

Programma Java che dimostra l'utilizzo di tutte le operazioni intermedie:

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 

Spiegazione:

• La listOfLists viene creata come una lista contenente altri elenchi di stringhe.
• flatMap(Lista::stream): Appiattisce gli elenchi nidificati in un unico flusso di stringhe.
• filter(s -> s.startsWith('S')) : filtra le stringhe per includere solo quelle che iniziano con "S".
• map(Stringa::toUpperCase) : converte ogni stringa nel flusso in maiuscolo.
• distinto() : rimuove eventuali stringhe duplicate.
• ordinato() : ordina le stringhe risultanti in ordine alfabetico.
• sbirciare(...): Aggiunge ogni elemento elaborato ai risultati intermedi impostati per l'ispezione intermedia.
• raccogli(Collectors.toList()): Raccoglie le stringhe elaborate finali in un elenco chiamato risultato.

Il programma stampa i risultati intermedi memorizzati nel set intermediResults. Infine stampa l'elenco dei risultati che contiene le stringhe completamente elaborate dopo tutte le operazioni di flusso.

Operazioni sui terminali

Le operazioni del terminale sono il tipo di operazioni che restituiscono il risultato. Queste operazioni non vengono elaborate ulteriormente, restituiscono solo un valore di risultato finale.

Importanti operazioni del terminale

1. raccogliere() : il metodo Collect viene utilizzato per restituire il risultato delle operazioni intermedie eseguite sul flusso.

Sintassi:

R raccogli(Collettorecollettore)

2. perOgni() : Il metodo forEach viene utilizzato per scorrere ogni elemento dello stream.

Sintassi:

void forEach(Consumatoreazione)

3. ridurre(): Il metodo reduce viene utilizzato per ridurre gli elementi di uno stream a un singolo valore. Il metodo reduce accetta BinaryOperator come parametro.

Sintassi:

T reduce(T identità BinaryOperatoraccumulatore)
Opzionaleridurre(OperatoreBinarioaccumulatore)

4. contare() : Restituisce il conteggio degli elementi nello stream.

Sintassi:

conteggio lungo()

5. trovaPrimo() : Restituisce il primo elemento dello stream se presente.

Sintassi:

OpzionaletrovaPrimo()

metodo Java uguale

6. allMatch() : controlla se tutti gli elementi del flusso corrispondono a un determinato predicato.

Sintassi:

booleano allMatch(Predicatepredicato)

7. Qualsiasi corrispondenza () : controlla se qualche elemento del flusso corrisponde a un determinato predicato.

Sintassi:

Qualsiasi corrispondenza booleana (predicatopredicato)

Qui alla variabile an viene assegnato 0 come valore iniziale e i viene aggiunto ad esso.

Nota: Le operazioni intermedie vengono eseguite in base al concetto di valutazione pigra che garantisce che ogni metodo restituisca un valore fisso (operazione terminale) prima di passare al metodo successivo.

Programma Java che utilizza tutte le operazioni del terminale:

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

Produzione:

Spiegazione:

• L'elenco dei nomi viene creato con stringhe di esempio.
• per ciascuno: Stampa ciascun nome nell'elenco.
• raccogliere : Filtra i nomi che iniziano con "S" e li raccoglie in un nuovo elenco.
• ridurre : concatena tutti i nomi in un'unica stringa.
• contare : Conta il numero totale di nomi.
• findFirst : Trova e stampa il primo nome nell'elenco.
• allMatch : Controlla se tutti i nomi iniziano con 'S'.
• sfortunato : Controlla se qualche nome inizia con 'S'.

Il programma stampa ciascun nome i nomi che iniziano con 'S' i nomi concatenati il ​​conteggio dei nomi il primo nome se tutti i nomi iniziano con 'S' e se qualche nome inizia con 'S'.

Vantaggio di Java Stream

Ci sono alcuni vantaggi per cui utilizziamo Stream in Java come menzionato di seguito:

• Nessun spazio di archiviazione
• Pipeline di funzioni
• Pigrizia
• Può essere infinito
• Può essere parallelizzato
• Può essere creato da raccolte matrici File Linee Metodi in Stream IntStream ecc.

Casi d'uso nel mondo reale di Java Streams

I flussi sono ampiamente utilizzati nelle moderne applicazioni Java per:

• Elaborazione dei dati
• Per l'elaborazione delle risposte JSON/XML
• Per le operazioni sul database
• Elaborazione simultanea