Manipulación de Streams en Java: Operaciones y Limitaciones

Curso de Programación Funcional con Java SE

Contenido del curso

Introducción a la programación Funcional

1
Programación Funcional en Java: Conceptos y Aplicaciones Prácticas
06:09 min

Entendiendo las partes de la programación funcional

Functional Programming en Java

Optional y Streams: Datos mas interesantes

Todo junto: Proyecto Job-search

Conclusiones

39
Programación Funcional en Java: Conceptos y Aplicaciones
00:37 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:18

Manipulación de Streams en Java: Operaciones y Limitaciones

Curso de Programación Funcional con Java SE

Clase 23 de 39

Clase 23 / 39

Recursos

¿Qué son las clases opcionales en programación?

Las clases opcionales son herramientas valiosas al manejar datos en programación, ya que permiten asegurar que los datos procesados sean seguros al dar la posibilidad de que un valor pueda o no existir. Esto es esencial para prevenir errores comunes como los null-pointer exceptions. Al implementar clases opcionales, el programador puede manejar valores ausentes de manera más elegante y segura, evitando operaciones en datos inexistentes y simplificando el flujo de trabajo.

Cómo trabajar con múltiples datos usando streams en Java

Trabajar con múltiples datos en Java a menudo plantea desafíos, especialmente cuando se trata de procesar colecciones grandes o complejas. Java 8 introduce el concepto de Stream, que ofrece una forma más efectiva de manejar estas operaciones al permitir el procesamiento de datos de manera más fluida y concisa.

¿Qué es un Stream en Java?

Un Stream es una secuencia de elementos respaldada por fuentes de datos como listas, mapas, arreglos u otras colecciones. Permite realizar distintas operaciones de manera declarativa, enfocándose en el "qué" en lugar del "cómo". Esto se logra a través de una API que soporta operaciones como filtrado, mapeo y reducción sobre la secuencia de datos, ofreciendo un enfoque más limpio en comparación con los bucles tradicionales.

¿Cómo crear y operar sobre un Stream?

Para aprovechar un flujo de datos con Stream, primero debemos crearlo y definir las operaciones a llevar a cabo sobre él. A continuación, se muestra un ejemplo:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {

    public static void main(String[] args) {
        
        // Creación de una lista de cursos
        List<String> cursos = Arrays.asList("Java", "Frontend", "Backend", "Rust");

        // Crear un Stream y aplicar operaciones
        List<String> cursosConPrefijo = cursos.stream()
                .map(curso -> "Platzi: " + curso)
                .collect(Collectors.toList());
        
        // Imprimir los resultados
        cursosConPrefijo.forEach(System.out::println);
    }
}

En este ejemplo, se crea un Stream a partir de una lista de cursos y se utiliza la operación map para agregar un prefijo "Platzi" a cada elemento. Finalmente, se colectan los resultados en una nueva lista y se imprimen.

¿Cómo gestionar datos con operaciones avanzadas en Stream?

Usando Stream, es posible realizar operaciones avanzadas que transformen y procesen datos de maneras más complejas, como el uso de funciones map y filter para transformar y seleccionar datos.

Ejemplo de operaciones avanzadas

Supongamos que queremos identificar cuál es el curso con el nombre más largo y aquellos que contienen la palabra "Java":

String cursoMasLargo = cursos.stream()
    .reduce((curso1, curso2) -> curso1.length() > curso2.length() ? curso1 : curso2)
    .orElse("No hay cursos disponibles");

List<String> cursosJava = cursos.stream()
    .filter(curso -> curso.contains("Java"))
    .collect(Collectors.toList());

System.out.println("Curso más largo: " + cursoMasLargo);
cursosJava.forEach(curso -> System.out.println("Curso con 'Java': " + curso));

Aquí se emplea reduce para encontrar el curso con el nombre más largo. Además, se usan filter y collect para obtener una lista de cursos que incluyen "Java".

¿Cuáles son las limitaciones del consumo de Streams?

Un aspecto crítico a tener en cuenta al trabajar con Stream es que solo pueden consumirse una vez. Después de operar sobre él, el Stream se considera "consumido" y no puede reutilizarse ni realizar más operaciones. Intentar hacerlo resulta en excepciones, lo cual es importante para evitar errores durante la ejecución.

Stream<String> stream = cursos.stream();

// Primera operación que consume el stream
boolean match = stream.anyMatch(curso -> curso.equals("Java"));

// Intentar reutilizar el mismo stream resultará en una excepción
//stream.forEach(System.out::println); // Esto arrojará una IllegalStateException

Este comportamiento es crucial al diseñar el flujo de procesamiento de datos para garantizar que el Stream se maneje con cuidado.

Al comprender estas prácticas y limitaciones, el poder de Stream en Java puede ser aplicado eficazmente para procesar colecciones de datos de forma clara, concisa y eficiente.

Tona Valencia

Hace 7 años

¿Cuales son los contras y los pros de usar For o Stream? ¿Por qué usar Stream cuando For parece ser una forma más fácil?

Sinuhe Jaime Valencia

Profesor

Hace 7 años

> ¿Cuales son los contras y los pros de usar For o Stream?

Algunos pros de usar for:

Muy probablemente ya lo conoces, entiendes y dominas
Es una estructura de control que en muchas ocasiones el compilador puede optimizar
Cuando tienes una clase que implementa la interfaz Iterable<E> puedes escribir tu for en la forma for-each (for(E e: iterableInstance){…}) que es bastante mas comoda que un for regular (for( inicializacion; condicion ; avance){…})
Manejar arreglos y colecciones es relativamente facil con un for

Algunos posibles contras (no necesarimente son malos o problematicos en todos los casos):

Es relativamente facil cometer errores que alteren el orden del for, por ejemplo, :

for(int i = 0; i < limite; i++){
// Algo de codigo
i = i % 2
// Mas codigo
}

Otro ejemplo de un posible error:

for(int index = 0; index < list.size(); i++) {
   //Algunas operaciones
   list.add(…); // Este es un error, creando un loop infinito 
}

La sintaxis podria no ser tan clara en un principo cuando se usan indices no tan obvios:

for(int i = …; … ; …) {
    for(int j = …; … : …) {
        //Error no tan obvio, deberia usarse la j pero se confunde con la i
        E myElement = myArray[i][i];
    }
}

Todos estos son casos hipoteticos, pero pueden llegar a pasar por descuidos pequeños.

La clase Stream esta pensada para que las iteraciones o el procesamiento de los elementos sea un poco mas "dinamicos".

En un for pones todas las operaciones dentro del for o escribes multiples for. En Stream cada operacion modifica el Stream y genera un nuevo Stream. Idealmente un Stream tiene nuevos elementos constantemente, por ello no puedes tener un metodo size() o un atributo/metodo length, pues no sabes cuantos elementos apareceran en el Stream. En teoria no puedes determinar cuando un Stream dejara de publicar elementos (idealmente). Sin embargo tienes la posibilidad de operara cada nuevo elemento que aparezca en el Stream.

Algunos pros de tener un Stream:

Es mucho mas facil hacer operaciones en paralelo
Es mas legible porque las operaciones son un poco mas explicitas (aunque depende del estilo de cada quien)
Tienes operaciones ya predefinidas
Hay muchas operaciones que son optimizadas en tiempo de compilacion
Puedes convertir facilmente un Stream<A> en un Stream<B> usando los metodos ya existentes en Stream
Puedes convertir facilmente muchas clases a Stream (por ejemplo, Collection#stream()
Al ser un tipo de dato puedes recibir o retornar Stream parcialmente operado:

public Stream<User> getUserNamesStream(){
    //Obtener los nombres de usuario
    return userNamesStream;
}
    
public Stream<String> getUserNamesByActiveStatus(Stream<String> users){
        return users.filter(User::isActive)
                .map(User::getUserName);
}

Algunos contras:

Cuando necesitas un dato final para mostrar o retornar algun dato final, tienes que convertir tu Stream
No tienes forma directa de frenar o saltarte pasos de una iteracion de un Stream a diferencia de un for donde puedes usar break y continue
Debes aprender la API de Stream
Buscar errores puede ser un poco mas complicado

Siendo realistas, habra ocasiones que sera mas simple usar un for para iterar una coleccion (List, Set, Map, Vector, etc.) y habra ocasiones que operar un Stream o generar un Stream demostrara un mejor performance o agregara mucha legbilidad.

Asi que la respuesta corta es: Depende de cada caso

Comentarios (24)24 comentarios

Gonzalo Muñoz

Hace 6 años

Antonio Madrid

Arturo Munoz Cantor

Ralph Sliger

Hace 5 años

Juan José Álvarez Pérez

Hace 4 años

Edinson Padrón

Carlos Ivan Garcia Fougerat

Juan Antonio García Sánchez

William Schnaider Torres Bermon

Usuario anónimo

User

Jean Nuñez

Christian Giraldo Ospina

Diego Boyatjian

Nicolas Botello Mendoza

Hace 3 años

Alejandro Manzano

Alexander Vasquez

Hace 2 años

ANDRES ALFONSO MIRA MEJIA

Gian HM

Alexandra Salazar

Reinaldo Mendoza

John Alassio

Andrés Antonio Azuara Portillo

Introducción a la programación Funcional

Programación Funcional en Java: Conceptos y Aplicaciones Prácticas

Entendiendo las partes de la programación funcional

Funciones en Programación Funcional: Conceptos Básicos

Funciones como Ciudadanos de Primera Clase en Programación

Funciones Puras: Concepto y Ejemplos Prácticos

Efectos Secundarios en Programación y su Impacto en el Código

Funciones de Orden Superior en Programación

Funciones Lambda en Programación Funcional Java

Inmutabilidad de Datos en Programación Funcional con Java

Functional Programming en Java

Programación Funcional en Java SE: Conceptos y Prácticas

Programación Funcional en Java: Práctica y Ejemplos en IntelliJ

Programación Funcional en Java: Creación y Uso de Funciones

Programación Funcional con Predicados en Java

Interfaz Consumer y Supplier en Java: Uso y Ejemplos Prácticos

Funciones Java para Transformación de Datos y Operaciones Binarias

Creación y Uso de Interfaces Funcionales Personalizadas en Java

Métodos de Referencia en Programación Funcional Java

Inferencia de tipos en Java: funciones y métodos

Uso de Expresiones Lambda en Java: Sintaxis y Aplicaciones

Interfaz Funcional en Java: Creación y Uso de Métodos Default

Encadenamiento de Llamadas en Programación Orientada a Objetos

Composición de Funciones en Programación Funcional

Optional y Streams: Datos mas interesantes

Uso de la Clase Optional en Java para Manejo de Valores Nulos

Manipulación de Streams en Java: Operaciones y Limitaciones

Programación Funcional en Java: Uso de Streams y Operaciones Terminales

Operaciones de Stream en Java: Intermedias y Finales

Operaciones y Concurrente con Stream en Java

Operaciones Terminales en Java Streams

Operaciones Intermedias en Streams de Java

Conversión de Strings a Listas de Enteros en Java

Todo junto: Proyecto Job-search

Construcción de Proyecto para Buscar Empleo Usando APIs

Configuración y Uso de Gradle en Proyectos Java con IntelliJ

Creación de una Herramienta de Búsqueda de Trabajo en Terminal

Creación de Puntos de Entrada y Dependencias en Proyectos Java

Creación de APIs RESTful con Feign y Spring Boot

Creación de una Interfaz de Línea de Comandos con JCommander

Validación de Argumentos en Terminal con Clases en Ciel

Procesamiento de Argumentos y Solicitudes API en Java

Creación de API para búsqueda de empleos con Java y CLI

Conclusiones

Programación Funcional en Java: Conceptos y Aplicaciones

Manipulación de Streams en Java: Operaciones y Limitaciones