El flux es va introduir a Java 8 l'API Stream s'utilitza per processar col·leccions d'objectes. Un flux en Java és una seqüència d'objectes que admet diversos mètodes que es poden canalitzar per produir el resultat desitjat. 

Ús de Stream a Java

Els usos de Stream a Java s'esmenten a continuació:

• Stream API és una manera d'expressar i processar col·leccions d'objectes.
• Permeteu-nos realitzar operacions com ara la reducció i l'ordenació de mapes de filtratge.

Com crear un flux Java

La creació de Java Stream és un dels passos més bàsics abans de considerar les funcionalitats de Java Stream. A continuació es mostra la sintaxi donada per declarar un flux Java.

java hola món

Sintaxi

Correntcorrent;

Aquí T és un objecte de classe o un tipus de dades depenent de la declaració.

Característiques de Java Stream

Les característiques dels fluxos de Java s'esmenten a continuació:

• Un flux no és una estructura de dades; només pren entrada de les matrius de col·leccions o dels canals d'E/S.
• Els fluxos no modifiquen les dades originals; només produeixen resultats amb els seus mètodes.
• Les operacions intermèdies (com ara el mapa de filtres, etc.) són mandrosos i retornen un altre flux perquè pugueu encadenar-los.
• Una operació de terminal (com la recollida per a cada recompte) finalitza el flux i dóna el resultat final.

Diferents operacions en fluxos

Hi ha dos tipus d'operacions en fluxos:

1. Operacions intermèdies
2. Operacions de terminal

Operacions intermèdies

Les operacions intermèdies són els tipus d'operacions en què s'encadenen diversos mètodes en fila.

Característiques de les operacions intermèdies

• Els mètodes estan encadenats.
• Les operacions intermèdies transformen un flux en un altre flux.
• Habilita el concepte de filtratge on un mètode filtra les dades i les passa a un altre després del processament.

Operacions intermèdies importants

Hi ha algunes operacions intermèdies esmentades a continuació:

1. mapa() : El mètode map s'utilitza per retornar un flux que consisteix en els resultats d'aplicar la funció donada als elements d'aquest flux.

Sintaxi:

Correntmapa (Funciómapeador)

2. filtre() : El mètode de filtre s'utilitza per seleccionar elements segons el predicat passat com a argument.

Sintaxi:

Correntfiltre (predicatpredicat)

3. ordenat() : El mètode ordenat s'utilitza per ordenar el flux.

Sintaxi:

Correntordenat ()
Correntordenat (Comparadorcomparador)

4. flatMap(): L'operació flatMap a Java Streams s'utilitza per aplanar un flux de col·leccions en un sol flux d'elements.

Sintaxi:

llançar cadena a int

CorrentflatMap (Funció> mapeador)

5. diferent() : elimina els elements duplicats. Retorna un flux que consta dels diferents elements (segons Object.equals(Object)).

Sintaxi:

Correntdiferent ()

6. ullada() : realitza una acció sobre cada element sense modificar el flux. Retorna un flux format pels elements d'aquest flux que, a més, realitza l'acció proporcionada a cada element a mesura que es consumeixen elements del flux resultant.

Sintaxi:

Correntpeek (Consumidoracció)

Programa Java que demostra l'ús de totes les operacions intermèdies:

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 

Explicació:

• El listOfLists es crea com una llista que conté altres llistes de cadenes.
• flatMap(Llista::stream): Aplana les llistes imbricades en un sol flux de cadenes.
• filtre(s -> s.startsWith('S')) : filtra les cadenes per incloure només les que comencen per 'S'.
• mapa(String::toUpperCase) : converteix cada cadena del flux en majúscules.
• diferent () : elimina les cadenes duplicades.
• ordenat () : Ordena les cadenes resultants alfabèticament.
• ullada (...): Afegeix cada element processat al conjunt intermediateResults per a la inspecció intermèdia.
• col·leccionar(Collectors.toList()): Recull les cadenes processades finals en una llista anomenada resultat.

El programa imprimeix els resultats intermedis emmagatzemats al conjunt intermediateResults. Finalment, imprimeix la llista de resultats que conté les cadenes completament processades després de totes les operacions de flux.

Operacions de terminal

Les operacions de terminal són el tipus d'operacions que retornen el resultat. Aquestes operacions no es processen més, només retornen un valor de resultat final.

Operacions importants de la terminal

1. recollir() : El mètode de recollida s'utilitza per retornar el resultat de les operacions intermèdies realitzades al flux.

Sintaxi:

R recull (Col·lectorcol·leccionista)

2. per cada() : El mètode forEach s'utilitza per iterar a través de tots els elements del flux.

Sintaxi:

void forEach (Consumidoracció)

3. reduir(): El mètode reduce s'utilitza per reduir els elements d'un flux a un sol valor. El mètode reduce pren un BinaryOperator com a paràmetre.

Sintaxi:

T redueix (T identitat BinaryOperatoracumulador)
Opcionalreduir(BinaryOperatoracumulador)

4. comptar () : retorna el recompte d'elements del flux.

Sintaxi:

recompte llarg ()

5. FindFirst() : retorna el primer element del flux si està present.

Sintaxi:

OpcionalfindFirst()

ordenació de llista de matrius

6. AllMatch() : Comprova si tots els elements del flux coincideixen amb un determinat predicat.

Sintaxi:

booleà allMatch (predicatpredicat)

7. Coincidència qualsevol () : Comprova si algun element del flux coincideix amb un determinat predicat.

Sintaxi:

Coincidència booleana qualsevol (predicatpredicat)

Aquí s'assigna a la variable 0 com a valor inicial i s'hi afegeix i.

Nota: Les operacions intermèdies s'executen basant-se en el concepte d'avaluació mandrosa que garanteix que cada mètode retorni un valor fix (operació de terminal) abans de passar al mètode següent.

Programa Java que utilitza totes les operacions del terminal:

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

Sortida:

Explicació:

• La llista de noms es crea amb cadenes d'exemple.
• per a cadascú: Imprimeix cada nom de la llista.
• recollir : filtra els noms que comencen per 'S' i els recull en una llista nova.
• reduir : Concatena tots els noms en una única cadena.
• comptar : compta el nombre total de noms.
• trobarPrimer : cerca i imprimeix el primer nom a la llista.
• AllMatch : Comprova si tots els noms comencen per 'S'.
• mala sort : Comprova si algun nom comença per 'S'.

El programa imprimeix els noms de cada nom que comencen per "S" noms concatenats el recompte de noms el primer nom si tots els noms comencen per "S" i si algun nom comença per "S".

Benefici de Java Stream

Hi ha alguns avantatges pels quals fem servir Stream a Java, tal com s'esmenta a continuació:

• Sense emmagatzematge
• Conducte de funcions
• Mandra
• Pot ser infinit
• Es pot paral·lelitzar
• Es pot crear a partir de matrius de col·leccions Fitxers Línies Mètodes a Stream IntStream, etc.

Casos d'ús del món real dels fluxos de Java

Els fluxos s'utilitzen àmpliament a les aplicacions Java modernes per a:

• Tractament de dades
• Per processar respostes JSON/XML
• Per a operacions de bases de dades
• Tramitació simultània