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.

programa de herencia en python

Sintaxis

Arroyoarroyo;

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:

1. Operaciones Intermedias
2. Operaciones terminales

Operaciones Intermedias

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:

Arroyomapa(Funciónmapeador)

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

Sintaxis:

Arroyofiltrar(Predicadopredicado)

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

Sintaxis:

Arroyoordenado()
Arroyoordenado(Comparadorcomparador)

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:

Arroyomapa plano(Función> mapeador)

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

Sintaxis:

Arroyodistinto()

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:

Arroyovistazo (consumidoracción)

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

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ó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.

declaración de caso de java

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

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

Sintaxis:

nulo para cada uno (consumidoracció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 BinaryOperatoracumulador)
Opcionalreducir(OperadorBinarioacumulador)

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:

OpcionalencontrarPrimero()

poda ab

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

Sintaxis:

booleano allMatch(Predicadopredicado)

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

Sintaxis:

Booleano Anymatch (Predicadopredicado)

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:

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:

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.

Casos de uso del mundo real de Java Streams

Las transmisiones se utilizan ampliamente en aplicaciones Java modernas para:

• Proceso de datos
• Para procesar respuestas JSON/XML
• Para operaciones de base de datos
• Procesamiento simultáneo