Les dejo un pequeño ayuda memorias :)

¿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.
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.
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.
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.
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.
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.
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".
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.
Les dejo un pequeño ayuda memorias :)

Imaginemos cuando trabajemos con la clase stream o un stream que es un flujo de datos. SÍ un flujo como si estos vinieran de una tubería o una corriente de la cual nosotros tenemos el control de esta (abrir y cerrarla a nuestro antojo). Este flujo tiene un recorrido que nosotros decidimos cómo trabajar con este.
Como en este ejemplo, de un flujo de datos filtramos los valores que** son peces** , los empacamos (Convertimos en un Objeto pez) y están listos para distribución. (Tenemos de retorno un listado de Objeto Pez).

⠀
Los Stream se utilizan para trabajar con colecciones de objetos, facilitando realizar operaciones de filtrado, mapeo, búsqueda, etc. No son una estructura de datos (como List o Map), sino que se trata de un flujo de datos.
⠀
Se pueden crear a partir de colecciones ya existentes pero se debe tener en cuenta que al tratarse de un flujo de datos, son de un solo uso, es decir, si se quiere operar conStream la misma colección varias veces, se debe crear uno nuevo cada vez.
⠀
Por ejemplo, se puede crear un Stream<String> a partir de una lista para procesar sus elementos aplicando funciones que a su vez devuelven otro :
StreamList<String> distroList = Arrays.asList("Ubuntu 22.04 LTS", "Kubuntu 21.10", "Manjaro Xfce Desktop");
Stream<String> distroStream = distroList.stream(); // crea un Stream a partir de la lista
Stream<String> ubuntuStream = distroStream.filter(distroName -> distroName.contains("ubuntu")); // Devuelve un nuevo Stream con los elementos que contengan el texto "ubuntu"
Stream<String> lowercaseStream = ubuntuStream.map(String::toLowerCase); // Devuelve un nuevo Stream con los nombres en minúsculas
Stream<String> lowDashStream = lowercaseStream.map(nombre -> nombre.replaceAll(" ", "-")); // Devuelve un nuevo Stream donde se han reemlazado los espacios por "_"
lowDashStream.forEach(System.out::println); // Se recorre el Stream para mostrar sus elementos
// En lugar de asignar cada Stream a una variable, se pueden encadenar las llamadas a las funciones y obtener el mismo resultado
distroList.stream()
.filter(distroName -> distroName.contains("ubuntu"))
.map(String::toLowerCase)
.map(nombre -> nombre.replaceAll(" ", "-"))
.forEach(System.out::println);
También existen funciones que tras operar sobre un Stream devuelven un tipo de dato distino. Algunos ejemplos son:
// Largo del String más largo
long largomaximo = distroList.stream()
.mapToInt(String::length) // Devuelve un Strean<Integer> con el largo de cada String
.max() // Si habían elementos, devuelve un Optional<Integer> con el valor máximo de los largos de las Strings
.orElse(0); // Si no había elementos, devuelve 0
// Devuelve true si alguno de los elementos de la lista contiene la cadena "Debian"
boolean contieneDebian = distroList.stream().anyMatch(nombre -> nombre.contains("Debian"));
// Devuelve true si ninguno de los elementos de la lista es un String vacío
boolean ningunoEstaVacio = distroList.stream().noneMatch(nombre -> nombre.isEmpty());
// Devuelve un String con los elementos de la lista separados por ", "
String todos = distroList.stream().reduce("", (acumulador, actual) -> acumulador + ", " + actual);
Se puede ver a un Stream como un iterador con esteroides, aumentado con el paradigma funcional. Por supuesto, esto es una forma muy básica de definirlo, pero al inicio facilita mucho imaginarlos de esta manera.
¿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?
¿Que son los Streams?
Los Stream se utilizan para procesar colecciones de objetos. Una secuencia es una secuencia de objetos que admite varios métodos que se pueden canalizar para producir el resultado deseado.
Las características de la secuencia de Java son:
Un flujo no es una estructura de datos, sino que toma información de las colecciones.
Los flujos no cambian la estructura de datos original, solo proporcionan el resultado según los métodos canalizados.
Cada operación intermedia se ejecuta de forma perezosa y devuelve un flujo como resultado, por lo que se pueden canalizar varias operaciones intermedias. Las operaciones de terminal marcan el final de la secuencia y devuelven el resultado.
Para practicar los streams recomiendo Codewars ya hay muchos ejercicios en los que se pueden usar para simplificar más el código
In this blog you can find more information.
Super! Adiós for :)
Cuando se genera un Stream solo puede ser consumido una vez