TRANSMITIR EN JAVA

La corriente se introdujo en Java 8 La API Stream se utiliza para procesar colecciones de objetos. Una secuencia en Java es una secuencia de objetos que admite varios métodos que pueden canalizarse para producir el resultado deseado.

Uso de Stream en Java

Los usos de Stream en Java se mencionan a continuación:

Stream API es una forma de expresar y procesar colecciones de objetos.
Permítanos realizar operaciones como filtrado, mapeo, reducción y clasificación.

Cómo crear una secuencia de Java

La creación de Java Stream es uno de los pasos más básicos antes de considerar las funcionalidades de Java Stream. A continuación se muestra la sintaxis proporcionada para declarar un flujo de Java.

Sintaxis

Arroyo arroyo;

Aquí T es un objeto de clase o un tipo de datos según la declaración.

Funciones de secuencia de Java

Las características de los flujos de Java se mencionan a continuación:

Un Stream no es una estructura de datos; solo toma información de Collections Arrays o canales de E/S.
Las transmisiones no modifican los datos originales; sólo producen resultados utilizando sus métodos.
Las operaciones intermedias (como el mapa de filtro, etc.) son diferidas y devuelven otra secuencia para que puedas encadenarlas.
Una operación de terminal (como recopilar para cada recuento) finaliza la transmisión y proporciona el resultado final.

Diferentes operaciones en corrientes

Hay dos tipos de Operaciones en Streams:

Operaciones Intermedias
Operaciones terminales

Operaciones Intermedias

Operaciones de flujo de Java

Las operaciones intermedias son los tipos de operaciones en las que se encadenan varios métodos seguidos.

Características de las operaciones intermedias

Los métodos están encadenados.
Las operaciones intermedias transforman una corriente en otra corriente.
Permite el concepto de filtrado en el que un método filtra datos y los pasa a otro método después del procesamiento.

Operaciones intermedias importantes

Hay algunas operaciones intermedias que se mencionan a continuación:

1. mapa() : El método map se utiliza para devolver una secuencia que consta de los resultados de aplicar la función dada a los elementos de esta secuencia.

Sintaxis:

Arroyo mapa(Función mapeador)

2. filtro() : El método de filtro se utiliza para seleccionar elementos según el predicado pasado como argumento.

Sintaxis:

Arroyo filtrar(Predicado predicado)

3. ordenado() : El método ordenado se utiliza para ordenar la secuencia.

Sintaxis:

Arroyo ordenado()
Arroyo ordenado(Comparador comparador)

4. mapa plano(): La operación flatMap en Java Streams se utiliza para aplanar un flujo de colecciones en un único flujo de elementos.

Sintaxis:

Arroyo mapa plano(Función > mapeador)

5. distinto() : Elimina elementos duplicados. Devuelve una secuencia que consta de elementos distintos (según Object.equals(Object)).

Sintaxis:

Arroyo distinto()

6. mirar() : Realiza una acción en cada elemento sin modificar la secuencia. Devuelve una secuencia que consta de los elementos de esta secuencia y además realiza la acción proporcionada en cada elemento a medida que los elementos se consumen de la secuencia resultante.

Sintaxis:

Arroyo vistazo (consumidor acción)

Programa Java que demuestra el uso de todas las operaciones intermedias:

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

Producción

Intermediate Results: STRUCTURE STREAM STATE SORTING Final Result: SORTING STATE STREAM STRUCTURE

Explicación:

listOfLists se crea como una lista que contiene otras listas de cadenas.
mapa plano(Lista::corriente): Aplana las listas anidadas en una única secuencia de cadenas.
filtro(s -> s.startsWith('S')) : Filtra las cadenas para incluir solo aquellas que comienzan con 'S'.
mapa(Cadena::aUpperCase) : convierte cada cadena de la secuencia a mayúsculas.
distinto() : Elimina cualquier cadena duplicada.
ordenado() : Ordena las cadenas resultantes alfabéticamente.
ojeada(...): Agrega cada elemento procesado al conjunto de resultados intermedios para la inspección intermedia.
recopilar (Coleccionistas.toList()): Recopila las cadenas procesadas finales en una lista llamada resultado.

El programa imprime los resultados intermedios almacenados en el conjunto de resultados intermedios. Finalmente, imprime la lista de resultados que contiene las cadenas completamente procesadas después de todas las operaciones de transmisión.

Operaciones terminales

Las Operaciones de Terminal son el tipo de Operaciones que devuelven el resultado. Estas operaciones no se procesan más, solo devuelven un valor de resultado final.

Operaciones terminales importantes

1. recoger() : El método de recopilación se utiliza para devolver el resultado de las operaciones intermedias realizadas en la secuencia.

Sintaxis:

R recoger(Coleccionista coleccionista)

2. para cada() : El método forEach se utiliza para recorrer cada elemento de la secuencia.

Sintaxis:

nulo para cada uno (consumidor acción)

3. reducir(): El método de reducción se utiliza para reducir los elementos de una secuencia a un único valor. El método de reducción toma un BinaryOperator como parámetro.

Sintaxis:

T reducir (T identidad BinaryOperator acumulador)
Opcional reducir(OperadorBinario acumulador)

4. contar() : Devuelve el recuento de elementos de la secuencia.

Sintaxis:

cuenta larga()

5. encontrarPrimero() : Devuelve el primer elemento de la secuencia si está presente.

Sintaxis:

Opcional encontrarPrimero()

6. todas las coincidencias() : Comprueba si todos los elementos de la secuencia coinciden con un predicado determinado.

Sintaxis:

booleano allMatch(Predicado predicado)

7. Cualquier coincidencia () : Comprueba si algún elemento de la secuencia coincide con un predicado determinado.

Sintaxis:

Booleano Anymatch (Predicado predicado)

Aquí a una variable se le asigna 0 como valor inicial y se le agrega i.

Nota: Las operaciones intermedias se ejecutan según el concepto de evaluación diferida que garantiza que cada método devuelva un valor fijo (operación terminal) antes de pasar al siguiente método.

Programa Java que utiliza todas las operaciones de 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  );      }   }

Producción:

Producción

Explicación:

La lista de nombres se crea con cadenas de muestra.
para cada uno: Imprime cada nombre de la lista.
recolectar : Filtra nombres que comienzan con 'S' y los recopila en una nueva lista.
reducir : Concatena todos los nombres en una sola cadena.
contar : Cuenta el número total de nombres.
encontrar primero : busca e imprime el primer nombre de la lista.
todo coincide : Comprueba si todos los nombres comienzan con 'S'.
desafortunado : Comprueba si algún nombre comienza con 'S'.

El programa imprime cada nombre, nombres que comienzan con 'S', nombres concatenados, el recuento de nombres, el primer nombre, si todos los nombres comienzan con 'S' y si algún nombre comienza con 'S'.

Beneficio de Java Stream

Existen algunos beneficios por los cuales usamos Stream en Java como se menciona a continuación:

Sin almacenamiento
Canal de funciones
Pereza
puede ser infinito
Se puede paralelizar
Se puede crear a partir de colecciones, matrices, archivos, líneas, métodos en Stream IntStream, etc.