TRANSMISSIÓ EN JAVA

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.

Sintaxi

Corrent corrent;

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:

Operacions intermèdies
Operacions de terminal

Operacions intermèdies

Operacions de flux de Java

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:

Corrent mapa (Funció mapeador)

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

Sintaxi:

Corrent filtre (predicat predicat)

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

Sintaxi:

Corrent ordenat ()
Corrent ordenat (Comparador comparador)

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

Sintaxi:

Corrent flatMap (Funció > mapeador)

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

Sintaxi:

Corrent diferent ()

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:

Corrent peek (Consumidor acció)

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

Java

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

Sortida

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·lector col·leccionista)

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

Sintaxi:

void forEach (Consumidor acció)

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 BinaryOperator acumulador)
Opcional reduir(BinaryOperator acumulador)

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

Sintaxi:

recompte llarg ()

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

Sintaxi:

Opcional findFirst()

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

Sintaxi:

booleà allMatch (predicat predicat)

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

Sintaxi:

Coincidència booleana qualsevol (predicat predicat)

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:

Java

    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:

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.