Carlos Fernández García

Ejercicio 1

Crea un programa en Java que, a partir de una lista de números enteros, filtre solo los números pares y los muestre en pantalla. Usa un Stream para realizar el filtrado de los números pares.

Ejercicio 2

Crea un programa en Java que, a partir de una lista de palabras, filtre y muestre solo aquellas palabras que tengan más de 4 caracteres. Usa un Stream para realizar el filtrado.

Ejercicio 3

Crea un programa en Java que, a partir de una lista de números enteros, eleve cada número al cuadrado y luego muestre los resultados. Usa un Stream para realizar la transformación de cada número.

Ejercicio 4

Crea un programa en Java que, a partir de una lista de nombres, convierta cada nombre a mayúsculas y luego muestre los resultados. Usa un Stream para realizar la transformación de cada nombre.

Ejercicio 5

Crea un programa en Java que, a partir de una lista de precios (en formato double), aplique un descuento del 20% a cada precio y luego muestre los precios finales. Usa un Stream para realizar la transformación de cada precio.

Ejercicio 6

Crea un programa en Java que, a partir de una lista de precios (en formato double), aplique un descuento del 20% a cada precio y luego muestre los precios finales. Usa un Stream para realizar la transformación de cada precio.

Ejercicio 7

Crea un programa en Java que, a partir de una lista de números enteros, convierta cada número en su representación en forma de cadena (String) y luego muestre los resultados. Usa un Stream para realizar la transformación de cada número.

Ejercicio 8

Crea un programa en Java que, a partir de una lista de nombres, filtre aquellos que comiencen con la letra 'A' y los muestre en pantalla. Usa un Stream para realizar el filtrado.

Ejercicio 9

Crea un programa en Java que, a partir de una lista de palabras, filtre y muestre solo aquellas que tienen una longitud impar. Usa un Stream para realizar el filtrado de las palabras.

Ejercicio 10

Crea un programa en Java que, a partir de una lista de números enteros, filtre y muestre solo aquellos que son múltiplos de 3. Usa un Stream para realizar el filtrado.

Ejercicio 11

Crea un programa en Java que, a partir de una lista de nombres, determine si todos los nombres tienen más de tres letras. Usa un Stream para realizar la verificación.

Ejercicio 12

Crea un programa en Java que, a partir de una lista de números enteros, verifique si al menos uno de los números es par. Usa un Stream para realizar la verificación.

Ejercicio 13

Crea un programa en Java que, a partir de una lista de números enteros, encuentre y muestre el mayor número presente en la lista. Usa un Stream para realizar la operación de búsqueda.

Ejercicio 14

Crea un programa en Java que, a partir de una lista de nombres, cuente cuántos nombres son únicos y los muestre. Usa un Stream para realizar la operación de conteo.

Ejercicio 15

Crea un programa en Java que, a partir de una lista de números enteros, sume todos los números que son mayores que 10 y muestre el resultado. Usa un Stream para realizar la operación de suma.

Ejercicio 16

Crea un programa en Java que, a partir de una lista de números enteros, determine cuántos números son impares y los muestre. Usa un Stream para realizar la operación de conteo.

Ejercicio 17

Crea un programa en Java que, a partir de una lista de palabras, muestre solo aquellas que empiezan con una vocal (sin importar si es mayúscula o minúscula). Usa un Stream para realizar el filtrado y muestra el resultado en pantalla.

package stream;

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

public class Ejercicio17 {

    public static void main(String[] args) {
        
        // Crear un objeto Scanner para leer la entrada del usuario
        Scanner entrada = new Scanner(System.in);
        
        // Inicializar una lista de palabras
        List<String> listaPalabras = Arrays.asList("Bea", "Teo", "Ana", "Emma", "Amparo", "Carlos", "Agustin", "Rita", "Noe", "Tonin");
        
        // Comprobar si la lista está vacía antes de continuar
        if(listaPalabras.isEmpty()) {
            System.out.println("La lista esta vacia");
        } else {
            // Declarar la variable para almacenar la vocal introducida por el usuario
            char vocal = ' ';
            
            // Bucle para asegurar que el usuario introduce una vocal válida
            while(true) {
                System.out.println("Introduce una vocal:");
                vocal = entrada.nextLine().toLowerCase().charAt(0);
                
                // Comprobar si el carácter introducido es una vocal
                if(vocal != 'a' && vocal != 'e' && vocal != 'i' && vocal != 'o' && vocal != 'u') {
                    System.out.println("No has introducido una vocal, introducela de nuevo");
                } else {
                    break; // Salir del bucle si el carácter es una vocal
                }
            }
            
            // Crear una variable final para almacenar la vocal y poder usarla dentro del Stream
            final char vocalFinal = vocal;
            
            // Filtrar y recoger las palabras que empiezan por la vocal introducida
            List<String> palabrasVocal = listaPalabras.stream()
                    .filter(n -> n.toLowerCase().charAt(0) == vocalFinal)
                    .collect(Collectors.toList());
            
            // Mostrar el resultado dependiendo de si existen palabras que cumplen la condición
            if(palabrasVocal.isEmpty()) {
                System.out.println("Ninguna palabra de la lista empezaba por '" + vocalFinal + "'");
            } else {
                System.out.println("Lista de palabras que empiezan por '" + vocalFinal + "'");
                System.out.println(palabrasVocal);
            }
        }
        
        // Cerrar el objeto Scanner
        entrada.close();
    }
}

Ejercicio 18

Crea un programa en Java que, a partir de una lista de números enteros, muestre los números duplicados (aquellos que aparecen más de una vez en la lista). Usa un Stream para identificar los duplicados y muestra el resultado en pantalla.

Ejercicio 19

Crea un programa en Java que, a partir de una lista de números enteros, genere una nueva lista con los cuadrados de los números impares. Usa un Stream para realizar el filtrado y la transformación, y muestra la lista resultante en pantalla.

Ejercicio 20

Crea un programa en Java que, a partir de una lista de cadenas de texto, muestre la longitud de cada cadena que contenga la letra "a" (sin importar si es mayúscula o minúscula). Usa un Stream para realizar el filtrado y la transformación, y muestra la lista de longitudes resultante en pantalla.

package stream;

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

public class Ejercicio20 {

    public static void main(String[] args) {
        // Lista de frases griegas
        List<String> frasesGriegas = Arrays.asList(
                "(1)Conócete a ti mismo. — Sócrates",
                "(2)La vida sin examen no vale la pena vivirla. — Sócrates",
                "(3)El conocimiento es la virtud. — Platón",
                "(4)La felicidad es un estado de ánimo que proviene de vivir en armonía con la virtud. — Aristóteles",
                "(5)La sabiduría comienza en la admiración. — Sócrates",
                "(6)El hombre es la medida de todas las cosas. — Protágoras",
                "(7)La justicia consiste en dar a cada uno lo que le corresponde. — Platón",
                "(8)No se puede entrar dos veces en el mismo río. — Heráclito",
                "(9)La paz es el mayor bien. — Platón",
                "(10)El que no tiene una meta no es un hombre. — Aristóteles",
                "(11)C*den* de c*r*cteres sin l* voc*l mencion*d* p*r* prueb*s - Yo"
        );
        
        // Verificar si la lista está vacía
        if (frasesGriegas.isEmpty()) {
            System.out.println("La lista está vacía");
        } else {
            // Filtrar cadenas que contienen 'a' y mapear a sus longitudes
            List<Integer> cadenasFiltradas = frasesGriegas.stream()
                    .filter(n -> n.toLowerCase().contains("a")) // Filtrar cadenas que contienen 'a'
                    .map(frase -> frase.length()) // Obtener la longitud de cada cadena filtrada
                    .collect(Collectors.toList()); // Recoger resultados en una lista
            
            // Comprobar si hay cadenas filtradas
            if (cadenasFiltradas.isEmpty()) {
                System.out.println("No había cadenas con la vocal 'a'");
            } else {
                // Imprimir las longitudes de las cadenas filtradas
                int index = 1;
                for (Integer integer : cadenasFiltradas) {
                    System.out.println(index + "-->" + integer);
                    index++;
                }
                System.out.println("Un total de " + (index - 1) + " cadenas contenían la vocal 'a'");
            }
        }
    }
}

Ejercicio 21

Crea un programa en Java que, a partir de una lista de números enteros, genere una nueva lista que contenga solo los números que son múltiplos de 3 y que estén en orden descendente. Usa un Stream para realizar el filtrado, la transformación y la ordenación, y muestra la lista resultante en pantalla.

Ejercicio 22

Crea un programa en Java que, a partir de una lista de cadenas de texto, genere una nueva lista que contenga solo aquellas cadenas que tengan más de 5 caracteres. Usa un Stream para realizar el filtrado y muestra la lista resultante en pantalla.

Ejercicio 23

Crea un programa en Java que, a partir de una lista de cadenas de texto, muestre solo aquellas que contienen al menos un dígito numérico. Usa un Stream para realizar el filtrado y muestra la lista resultante en pantalla.

Ejercicio 24

Crea un programa en Java que, a partir de una lista de cadenas de texto, muestre solo aquellas que contienen al menos un dígito numérico. Usa un Stream para realizar el filtrado y muestra la lista resultante en pantalla.

Ejercicio 25

Crea un programa en Java que, a partir de una lista de palabras, genere una nueva lista que contenga solo aquellas palabras que tengan una longitud par. Usa un Stream para realizar el filtrado y muestra la lista resultante en pantalla.

Ejercicio 26

Crea un programa en Java que, a partir de una lista de números enteros, genere una nueva lista que contenga el resultado de multiplicar cada número por 2 solo si el número es impar. Usa un método distinto a filter y map para realizar esta operación, y muestra la lista resultante en pantalla. Esto te permitirá explorar otros métodos de Streams, como flatMap o forEach, para trabajar con la lista de números.

Ejercicio 27

Crea un programa en Java que, a partir de una lista de números enteros, calcule el producto de todos los números positivos de la lista. Usa el método reduce para realizar esta operación. Si la lista no contiene ningún número positivo, el programa debe mostrar un mensaje indicando que no hay números positivos y el producto debe ser 1 por defecto

Ejercicio 28

Crea un programa en Java que, a partir de una lista de palabras, calcule la longitud total de todos los caracteres combinados en aquellas palabras que tienen una longitud mayor a 4 caracteres. Usa reduce para realizar esta operación y muestra el resultado en pantalla.

Ejercicio 29

Crea un programa en Java que, a partir de una lista de números enteros, encuentre el número mayor y menor de la lista utilizando el método reduce. Si la lista está vacía, muestra un mensaje indicando que no hay números para comparar. Muestra en pantalla el número mayor y el menor encontrados.

Ejercicio 30

Crea un programa en Java que, a partir de una lista de números enteros, calcule el producto de todos los números en la lista. Si la lista está vacía, muestra un mensaje indicando que no hay números para multiplicar. Usa el método reduce para realizar esta operación y muestra el resultado en pantalla.

Ejercicio 31

Crea un programa en Java que, a partir de una lista de precios de productos (números decimales), calcule el precio total después de aplicar un descuento fijo del 10% en cada producto. Usa reduce para realizar esta operación y muestra el precio total en pantalla. Si la lista está vacía, muestra un mensaje indicando que no hay precios para calcular.

Ejercicio 32

Crea un programa en Java que, a partir de una lista de cadenas de texto, * combine todas las palabras en una sola cadena, separándolas con un espacio. * Usa reduce para realizar esta operación y muestra la cadena resultante en pantalla. * Si la lista está vacía, muestra un mensaje indicando que no hay palabras para combinar.

Ejercicio 33

Crea un programa en Java que, a partir de una lista de números enteros, encuentre la diferencia total entre los números, * tomando el primero de la lista como valor inicial y restando cada uno de los siguientes. Usa reduce para realizar esta * operación y muestra el resultado en pantalla. Si la lista está vacía, muestra un mensaje indicando que no hay números * para procesar. * * Por ejemplo, para la lista [20, 5, 3, 2], el resultado debería ser 20 - 5 - 3 - 2 = 10.

Ejercicio 34

Crea un programa en Java que, a partir de una lista de nombres de ciudades (cadenas de texto), encuentre el nombre de la ciudad más larga. Usa el método reduce para realizar esta operación y muestra en pantalla el nombre de la ciudad más larga encontrado. Si la lista está vacía, muestra un mensaje indicando que no hay ciudades para comparar. Ejemplo de lista: Para la lista de ciudades ["Madrid", "Barcelona", "Sevilla", "Valencia"], el resultado debería ser "Barcelona".

Ejercicio 35

Crea un programa en Java que, a partir de una lista de cadenas de texto, cuente la cantidad total de caracteres en todas las cadenas. Usa el método reduce para realizar esta operación y muestra el resultado en pantalla. Si la lista está vacía, muestra un mensaje indicando que no hay cadenas para contar. Por ejemplo, para la lista ["Hola", "mundo", "Java"], el resultado debería ser 13 (4 + 5 + 4).

Ejercicio 36

Crea un programa que: Tenga una lista de números enteros. Use Streams para: Filtrar solo los números pares. Mostrarlos por pantalla. 🔹 Datos de ejemplo La lista puede ser: List numeros = List.of(1, 2, 3, 4, 5, 6, 7, 8); 🔹 Objetivo esperado en consola 2 4 6 8 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .forEach() Usa una lambda

Ejercicio 37

Crea un programa que: Tenga una lista de nombres. Use Streams para: Filtrar los nombres que tengan más de 4 letras. Convertirlos a mayúsculas. Mostrarlos por pantalla. 🔹 Datos de ejemplo List nombres = List.of("Ana", "Luis", "Pedro", "Marta", "Sol"); 🔹 Objetivo esperado en consola PEDRO MARTA 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar .forEach() Usa lambdas

Ejercicio 38

Crea un programa que: Tenga una lista de números enteros. Use Streams para: Filtrar los números mayores que 10. Multiplicar esos números por 2. Guardar el resultado en una nueva lista. Mostrar la nueva lista por pantalla. 🔹 Datos de ejemplo List numeros = List.of(5, 8, 12, 3, 20, 15); 🔹 Objetivo esperado en consola [24, 40, 30] 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar .collect() Usa lambdas

Ejercicio 39

Crea un programa que: Tenga una lista de números enteros. Use Streams para: Filtrar los números impares. Eliminar los números repetidos. Ordenar los números de menor a mayor. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List numeros = List.of(4, 7, 2, 7, 9, 4, 12, 15, 2); 🔹 Objetivo esperado en consola [7, 9, 15] 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .distinct() Debes usar .sorted() Debes usar .forEach() o .collect() Usa lambdas

Ejercicio 40

Crea un programa que: Tenga una lista de estudiantes con sus edades. Use Streams para: Filtrar los estudiantes que sean mayores o iguales a 18 años. Obtener solo los nombres de esos estudiantes. Ordenarlos alfabéticamente. Mostrar los nombres por pantalla. 🔹 Datos de ejemplo List estudiantes = List.of("Ana-17", "Luis-20", "Pedro-18", "Marta-16", "Carlos-22"); 🔹 Objetivo esperado en consola Carlos Luis Pedro 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar .sorted() Debes usar .forEach() o .collect() Usa lambdas

Ejercicio 41

Crea un programa que: Tenga una lista de números enteros. Use Streams para: Filtrar los números mayores que 0. Calcular la suma de esos números. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List numeros = List.of(-3, 5, 10, -2, 8, -1); 🔹 Objetivo esperado en consola 23 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .reduce() Usa lambdas

Ejercicio 42

Crea un programa que: Tenga una lista de números enteros. Use Streams para: Filtrar los números pares. Multiplicar esos números por 3. Eliminar los valores duplicados. Ordenarlos de mayor a menor. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List numeros = List.of(2, 4, 4, 6, 7, 8, 10, 2, 3); 🔹 Objetivo esperado en consola [30, 24, 18, 6] 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar .distinct() Debes usar .sorted() Debes usar .collect() o .toList() Usa lambdas

Ejercicio 43

Crea un programa que: Tenga una lista de nombres. Use Streams para: Filtrar los nombres que tengan más de 4 letras. Convertir esos nombres a mayúsculas. Agruparlos por su primera letra. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List nombres = List.of("Ana", "Luis", "Pedro", "Marta", "Carlos", "Lucia"); 🔹 Objetivo esperado en consola (formato aproximado) {P=[PEDRO], M=[MARTA], C=[CARLOS], L=[LUCIA]} 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar Collectors.groupingBy() Usa lambdas

Ejercicio 44

Crea un programa que: Tenga una lista de palabras. Use Streams para: Filtrar las palabras que empiecen por la letra "A". Convertirlas a minúsculas. Ordenarlas alfabéticamente. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List palabras = List.of("Avion", "Casa", "Arbol", "Perro", "Amigo", "Sol"); 🔹 Objetivo esperado en consola [amigo, arbol, avion] 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar .sorted() Debes usar .toList() o .collect() Usa lambdas

Ejercicio 45

Crea un programa que: Tenga una lista de números enteros. Use Streams para: Filtrar los números impares. Elevar cada número al cuadrado. Ordenarlos de menor a mayor. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List numeros = List.of(1, 2, 3, 4, 5, 6); 🔹 Objetivo esperado en consola [1, 9, 25] 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar .sorted() Debes usar .toList() o .collect() Usa lambdas

Ejercicio 46

Crea un programa que: Tenga una lista de frases. Use Streams para: Filtrar las frases que contengan la palabra "java" (sin importar mayúsculas/minúsculas). Obtener la longitud de cada frase filtrada. Eliminar longitudes duplicadas. Ordenarlas de mayor a menor. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List frases = List.of( "Me gusta Java", "Java es potente", "Python es popular", "Aprendiendo java streams", "Hola mundo" ); 🔹 Objetivo esperado en consola (formato aproximado) [24, 16, 13] 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar .distinct() Debes usar .sorted() Debes usar .toList() o .collect() Usa lambdas

Ejercicio 47

Crea un programa que: Tenga una lista de productos con precio. Use Streams para: Filtrar los productos que tengan un precio mayor a 20. Aumentar el precio de esos productos en un 10%. Eliminar los productos duplicados (por nombre). Ordenarlos por precio de menor a mayor. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List productos = List.of( "Laptop-800", "Mouse-15", "Teclado-30", "Monitor-200", "Mouse-15", "Cable-10" ); 🔹 Objetivo esperado en consola (formato aproximado) [Laptop-880.0, Teclado-33.0, Monitor-220.0] 🔹 Restricción Debes usar .stream() Debes usar .filter() Debes usar .map() Debes usar .distinct() Debes usar .sorted() Debes usar .toList() o .collect() Usa lambdas

Ejercicio 48

Crea un programa que: Tenga una lista de números enteros. Use Streams para: Filtrar los números mayores que 10. Multiplicar cada número filtrado por 3. Eliminar los resultados que sean pares. Ordenarlos de mayor a menor. Mostrar el resultado final en una lista. 🔹 Datos de ejemplo List numeros = List.of(5, 12, 7, 20, 3, 15, 8); 🔹 Explicación esperada Mayores que 10 → [12, 20, 15] Multiplicados por 3 → [36, 60, 45] Eliminar pares → [45] Ordenar desc → [45] 🔹 Objetivo esperado en consola [45] 🔹 Restricción Debes usar: .stream() .filter() .map() .sorted() .toList() o .collect() Usa lambdas

Ejercicio 49

Crea un programa que: Tenga una lista de nombres. Use Streams para: Filtrar los nombres que tengan más de 4 letras. Convertir cada nombre filtrado a mayúsculas. Ordenarlos alfabéticamente. Obtener el total de letras sumando la longitud de todos los nombres resultantes. Mostrar por pantalla: - La lista final - El total de letras

Ejercicio 50

Crea un programa que: Tenga una lista de empleados con salario. Use Streams para: Filtrar los empleados que tengan un salario mayor a 2000. Aumentar el salario de esos empleados en un 15%. Eliminar los empleados duplicados (por nombre). Ordenarlos por salario de mayor a menor. Mostrar el resultado por pantalla. 🔹 Datos de ejemplo List empleados = List.of( "Ana-1800", "Luis-2500", "Carlos-3000", "Marta-2200", "Luis-2500", "Pedro-1500" ); 🔹 Objetivo esperado en consola (formato aproximado) [Luis-2875.00, Carlos-3450.00, Marta-2530.00] 🔹 Restricción Debes usar: .stream() .filter() .map() .distinct() .sorted() .toList() o .collect() Usa lambdas

Ejercicio 51

Crea un programa que: Tenga una lista de números enteros. Use Streams para: 1️⃣ Eliminar números duplicados. 2️⃣ Filtrar solo los números pares. 3️⃣ Elevar cada número al cuadrado. 4️⃣ Ordenarlos de menor a mayor. 5️⃣ Calcular la suma total de los números resultantes. 6️⃣ Mostrar: - La lista final - La suma total 🔹 Datos de ejemplo List numeros = List.of( 3, 8, 2, 8, 5, 10, 3, 4 ); 🔹 Explicación esperada Sin duplicados → [3, 8, 2, 5, 10, 4] Solo pares → [8, 2, 10, 4] Al cuadrado → [64, 4, 100, 16] Ordenados → [4, 16, 64, 100] Suma → 184 🔹 Salida esperada (aprox) Lista final: [4, 16, 64, 100] Suma total: 184 🔹 Restricción Debes usar: .stream() .distinct() .filter() .map() .sorted() .toList() o .collect() mapToInt().sum() o reduce() Usa lambdas.

Ejercicio 52

Crea un programa que: Tenga una lista de palabras. Use Streams para: 1️⃣ Agrupar las palabras por su longitud. 2️⃣ Contar cuántas palabras hay de cada longitud. 3️⃣ Obtener la longitud que más se repite. 4️⃣ Mostrar: - El mapa agrupado - La longitud más frecuente 🔹 Datos de ejemplo List palabras = List.of( "sol", "mar", "cielo", "luna", "estrella", "rio", "montaña", "mar" ); 🔹 Resultado esperado (aprox) Agrupación: {3=4, 4=1, 5=1, 7=1, 8=1} Longitud más frecuente: 3 🔹 Restricción Debes usar: .stream() .collect() Collectors.groupingBy() Collectors.counting() .entrySet() .max() Optional Usa lambdas.

Ejercicio 53

Crea un programa que: Tenga una lista de números enteros. Use Streams para: 1️⃣ Encontrar el primer número mayor que 50. 2️⃣ Verificar si existe al menos un número múltiplo de 7. 3️⃣ Verificar si todos los números son positivos. 4️⃣ Obtener cualquier número impar de la lista. 5️⃣ Mostrar todos los resultados por pantalla. 🔹 Datos de ejemplo List numeros = List.of( 10, 25, 40, 55, 70, 3, -5, 14 ); 🔹 Resultado esperado (aprox) Primer número > 50: 55 Existe múltiplo de 7: true Todos positivos: false Número impar encontrado: 25 🔹 Restricción Debes usar: .stream() .filter() .findFirst() .findAny() .anyMatch() .allMatch() Usa lambdas.

Ejercicio 54

Crea un programa que: Tenga una lista de números enteros. List numeros = List.of( 12, 7, 5, 20, 33, 18, 9 ); Usa Streams para: 1️⃣ Calcular la suma total de los números. 2️⃣ Calcular el producto total de los números. 3️⃣ Obtener el número máximo. 4️⃣ Obtener el número mínimo. 5️⃣ Contar cuántos números hay en la lista. 🔒 Restricción Debes usar: .stream() .reduce() .max() .min() .count() Usa lambdas.

Ejercicio 55

Crea una clase Empleado con: String nombre String departamento double salario Crea esta lista: List empleados = List.of( new Empleado("Ana", "IT", 2500), new Empleado("Luis", "IT", 3200), new Empleado("Marta", "HR", 2100), new Empleado("Carlos", "HR", 2800), new Empleado("Sofia", "Ventas", 3000), new Empleado("Pedro", "Ventas", 1900) ); 🔥 Debes usar Streams para: 1️⃣ Obtener una lista solo con los nombres. 2️⃣ Obtener los empleados con salario mayor a 2500. 3️⃣ Agrupar los empleados por departamento. 4️⃣ Calcular el salario promedio de todos los empleados. 5️⃣ Crear un Map donde: La clave sea el departamento El valor sea el salario promedio de ese departamento 🔒 Restricción Debes usar: .map() .filter() .collect() Collectors.toList() Collectors.groupingBy() Collectors.averagingDouble()


package stream;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

public class Ejercicio55 {

	public static void main(String[] args) {

		// 🔹 Lista de empleados inicial
		List<Empleado> empleados = List.of(
			    new Empleado("Ana", "IT", 2500),
			    new Empleado("Luis", "IT", 3200),
			    new Empleado("Marta", "HR", 2100),
			    new Empleado("Carlos", "HR", 2800),
			    new Empleado("Sofia", "Ventas", 3000),
			    new Empleado("Pedro", "Ventas", 1900)
			);

		// 🔹 1️⃣ Obtener solo los nombres usando map
		List<String> nombres = empleados.stream()
				.map(n -> n.getNombre())
				.toList();

		// 🔹 2️⃣ Filtrar empleados con salario mayor a 2500
		List<Empleado> salarioMax2500 = empleados.stream()
				.filter(n -> n.getSalario() > 2500)
				.collect(Collectors.toList());

		// =========================
		// 🔹 RESULTADOS POR PANTALLA
		// =========================

		System.out.println("La lista de los nombres -> " + nombres);

		System.out.println("\nLa lista de los empleados con salario superior a 2500:");

		// 🔹 Mostrar empleados filtrados con formato limpio
		for (Empleado empleado : salarioMax2500) {
			System.out.println("Empleado -> " + empleado.getNombre());
			System.out.println("Departamento -> " + empleado.getDepartamento());
			System.out.println("Salario -> " + String.format("%.2f€", empleado.getSalario()));
			System.out.println();
		}

		// 🔹 3️⃣ Agrupar empleados por departamento
		Map<String, List<Empleado>> agrupacion = empleados.stream()
		        .collect(Collectors.groupingBy(Empleado::getDepartamento));

		System.out.println("=== Empleados agrupados por departamento ===");

		// 🔹 Mostrar agrupación con formato profesional
		agrupacion.forEach((departamento, listaEmpleados) -> {

		    System.out.println("\nDepartamento: " + departamento);

		    listaEmpleados.forEach(e ->
		            System.out.println("  - " +
		                    e.getNombre() +
		                    " -> " +
		                    String.format("%.2f€", e.getSalario())
		            )
		    );
		});

		// 🔹 4️⃣ Calcular salario promedio total
		System.out.println("\nEl salario promedio total es -> " +
				String.format("%.2f€",
				empleados.stream()
					.collect(Collectors.averagingDouble(Empleado::getSalario))
				)
		);

		// 🔹 5️⃣ Calcular salario promedio por departamento
		Map<String, Double> departamentoSalario = empleados.stream()
				.collect(Collectors.groupingBy(
						Empleado::getDepartamento,
						Collectors.averagingDouble(Empleado::getSalario)
				));

		System.out.println("\nMedia de salarios por departamento:");

		// 🔹 Mostrar el Map de forma limpia
		for (Entry<String, Double> departamento : departamentoSalario.entrySet()) {
			System.out.println(
					departamento.getKey() +
					" -> " +
					String.format("%.2f€", departamento.getValue())
			);
		}

	}

}

class Empleado {

	String nombre;
	String departamento;
	double salario;

	public Empleado(String nombre, String departamento, double salario) {

		this.nombre = nombre;
		this.departamento = departamento;
		this.salario = salario;
	}

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getDepartamento() {
		return departamento;
	}

	public void setDepartamento(String departamento) {
		this.departamento = departamento;
	}

	public double getSalario() {
		return salario;
	}

	public void setSalario(double salario) {
		this.salario = salario;
	}

	// 🔹 Representación limpia del objeto
	@Override
	public String toString() {
		return "Nombre -> " + nombre +
				"\nDepartamento -> " + departamento +
				"\nSalario -> " + String.format("%.2f€", salario) + "\n";
	}
}

Ejercicio 56

Tienes esta lista: List numeros = List.of( 12, 7, 5, 20, 33, 18, 9, 42, 27, 3, 15 ); 🔥 Debes usar Streams para: 1️⃣ Separar los números en pares e impares usando partitioningBy(). Debe devolverte un: Map> 2️⃣ Obtener estadísticas completas usando summarizingInt(): Devuelve un objeto con: suma promedio máximo mínimo cantidad 3️⃣ Obtener el primer número mayor que 25 usando findFirst(). Devuelve Optional 4️⃣ Comprobar si todos los números son mayores que 0 usando allMatch(). 5️⃣ Comprobar si existe algún número mayor que 40 usando anyMatch(). 🔒 Restricción Debes usar: partitioningBy() Collectors.summarizingInt() findFirst() allMatch() anyMatch()


package stream;

import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

public class Ejercicio56 {

	public static void main(String[] args) {

		// 🔹 Lista de números de ejemplo
		List<Integer> numeros = List.of(
			    12, 7, 5, 20, 33, 18, 9, 42, 27, 3, 15
			);

		// ==============================
		// 🔥 1️⃣ PartitioningBy
		// Separa los números en pares e impares
		// Devuelve un Map<Boolean, List<Integer>>
		// true  -> Pares
		// false -> Impares
		// ==============================
		Map<Boolean,List<Integer>> resultado = numeros.stream()
				.collect(Collectors.partitioningBy(n -> n % 2 == 0));

		// 🔹 Mostrar resultado de la partición
		for (Map.Entry<Boolean, List<Integer>> entry : resultado.entrySet()) {
			System.out.println("Clave -> " + (entry.getKey() ? "Pares" : "Impares"));
			System.out.println("Valores -> " + entry.getValue());
		}

		// ==============================
		// 🔥 2️⃣ Estadísticas completas
		// summarizingInt genera un objeto con:
		// suma, promedio, max, min y cantidad
		// ==============================
		IntSummaryStatistics estadisticas = numeros.stream()
				.collect(Collectors.summarizingInt(n -> n));

		System.out.println("\n===== Estadísticas =====");
		System.out.println("Suma -> " + estadisticas.getSum());
		System.out.println("Promedio -> " + String.format("%.2f", estadisticas.getAverage()));
		System.out.println("Máximo -> " + estadisticas.getMax());
		System.out.println("Mínimo -> " + estadisticas.getMin());
		System.out.println("Cantidad -> " + estadisticas.getCount());

		// ==============================
		// 🔥 3️⃣ Primer número mayor que 25
		// Devuelve Optional<Integer>
		// ==============================
		Optional<Integer> numeroMayor25 = numeros.stream()
				.filter(n -> n > 25)
				.findFirst();

		// ==============================
		// 🔥 4️⃣ Verificar si todos son positivos
		// allMatch devuelve true/false
		// ==============================
		boolean positivos = numeros.stream()
				.allMatch(n -> n > 0);

		// ==============================
		// 🔥 5️⃣ Verificar si existe alguno mayor que 40
		// anyMatch devuelve true si al menos uno cumple
		// ==============================
		boolean mayor40 = numeros.stream()
				.anyMatch(n -> n > 40);

		// ==============================
		// 🔹 Mostrar resultados finales
		// ==============================
		System.out.println("\nPrimer numero mayor que 25 -> "
				+ numeroMayor25.orElse(null));

		System.out.println("¿Todos son positivos? -> " + (positivos ? "Si" : "No"));

		System.out.println("¿Existe algun numero mayor que 40? -> "
				+ (mayor40 ? "Si" : "No"));
	}
}

Ejercicio 57

Dada la siguiente lista de números enteros: List numeros = List.of( 5, 12, 8, 20, 33, 15, 12, 40, 7, 18, 25, 30, 5 ); Realiza las siguientes operaciones usando Streams de forma independiente (mostrando cada resultado por consola): 1️⃣ Usa peek() para imprimir los valores mientras pasan por el flujo. 2️⃣ Usa filter() para quedarte solo con los números mayores que 10. 3️⃣ Usa sorted() junto con takeWhile() para obtener los números menores que 30. 4️⃣ Usa sorted() junto con dropWhile(). 5️⃣ Usa distinct() para eliminar duplicados. 6️⃣ Usa sorted() para ordenar la lista completa. 7️⃣ Usa findFirst() y findAny() mostrando la diferencia. 8️⃣ Usa allMatch(), anyMatch() y noneMatch() para validar condiciones. 9️⃣ Usa reduce() para calcular la suma total.


package stream;

import java.util.List;



public class Ejercicio57 {

	public static void main(String[] args) {
		
		// Lista base de números enteros
		List<Integer> numeros = List.of(
			    5, 12, 8, 20, 33, 15, 12, 40, 7, 18, 25, 30, 5
			);
		
		// Uso de peek() para observar cómo pasan los elementos por el flujo
		// Se necesita una operación terminal (forEach) para que se ejecute
		numeros.stream()
		.peek(n -> {
			System.out.println("Inicio");
			System.out.println(n);
			System.out.println("Final");
		})
		.forEach(System.out::println); // Operación terminal
		
		// Filtra números mayores que 10
		System.out.println("Los numeros mayores que 10: " + numeros.stream()
			.filter(n -> n > 10)
			.toList());
		
		// Ordena y toma los números mientras sean menores que 30
		System.out.println("Los numeros menores que 30 ordenados: " + numeros.stream()
			.sorted()
			.takeWhile(n -> n < 30)
			.toList());
		
		// Ordena y descarta elementos mientras la condición se cumpla
		// (dropWhile solo actúa desde el inicio del stream)
		System.out.println("Uso de dropWhile tras ordenar: " + numeros.stream()
				.sorted()
				.dropWhile(n -> n == 15)
				.toList());
		
		// Elimina los elementos duplicados
		System.out.println("La lista eliminando duplicados: " + numeros.stream()
				.distinct()
				.toList());
		
		// Ordena toda la lista
		System.out.println("La lista ordenada: " + numeros.stream()
				.sorted()
				.toList());
		
		// Diferencia entre findFirst() y findAny()
		System.out.println("Mostrando diferencia entre 'findFirst' y 'findAny': ");
		
		// Devuelve el primer elemento del stream
		System.out.println("'findFirst: ' " + numeros.stream()
				.findFirst()
				.orElse(null));
		
		// Devuelve cualquier elemento que cumpla la condición (en stream secuencial suele ser el primero encontrado)
		System.out.println("'findAny: ' " + numeros.stream()
		.filter(n -> n % 2 == 0)
		.findAny()
		.orElse(null));
		
		// Comprueba si todos los números son mayores que 0
		System.out.println("¿Son todos los numeros mayores que 0? " + 
				(numeros.stream().allMatch(n -> n > 0) ? "Si" : "No"));
		
		// Comprueba si existe algún número menor que 0
		System.out.println("¿Hay algun numero menor que 0? " + 
				(numeros.stream().anyMatch(n -> n < 0) ? "Si" : "No"));
		
		// Comprueba si ningún número es menor que 0
		System.out.println("¿Ninguno menor que 0? " + 
				(numeros.stream().noneMatch(n -> n < 0) ? "Si" : "No"));
		
		// Calcula la suma total de los números usando reduce
		System.out.println("La suma de todos los numeros de la lista es -> " + 
				numeros.stream()
				.reduce(Integer::sum)
				.orElse(null));
	}
}

Ejercicio 58

Crea una clase llamada Producto con los siguientes atributos: - String nombre - String categoria - double precio - int stock Crea una lista con varios productos variados (distintas categorías, precios y cantidades). Realiza las siguientes operaciones usando Streams (mostrando cada resultado por consola de forma independiente): 1️⃣ Filtra los productos con precio mayor a 50. 2️⃣ Obtén solo los nombres de los productos usando map(). 3️⃣ Calcula el precio total del inventario (precio * stock) usando map() + reduce(). 4️⃣ Ordena los productos por precio de menor a mayor. 5️⃣ Agrupa los productos por categoría usando groupingBy(). 6️⃣ Obtén el producto más caro usando max() y Comparator. 7️⃣ Comprueba si existe algún producto sin stock usando anyMatch(). Cada operación debe hacerse con un Stream independiente.


package stream;

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

public class Ejercicio58 {

	public static void main(String[] args) {
		
		// Lista de productos de ejemplo con distintas categorías, precios y stock
		List<Producto> productos = List.of(
			    new Producto("Portátil Lenovo", "Tecnologia", 850.00, 5),
			    new Producto("Ratón Logitech", "Tecnologia", 25.99, 30),
			    new Producto("Teclado Mecánico", "Tecnologia", 79.90, 12),
			    new Producto("Silla Oficina", "Hogar", 120.50, 8),
			    new Producto("Mesa Escritorio", "Hogar", 210.00, 3),
			    new Producto("Cafetera", "Electrodomesticos", 65.00, 15),
			    new Producto("Microondas", "Electrodomesticos", 99.99, 6),
			    new Producto("Zapatillas Running", "Deporte", 89.95, 20),
			    new Producto("Mancuernas 10kg", "Deporte", 45.00, 0),
			    new Producto("Mochila Urbana", "Accesorios", 39.99, 18)
			);

		// 1️⃣ Filtrar productos cuyo precio sea mayor a 50€
		System.out.println("Los articulos que valen mas de 50€:\n");
		productos.stream()
				.filter(n -> n.getPrecio() > 50) // Se quedan solo los productos > 50
				.forEach(System.out::println); // Se imprimen los productos resultantes
		
		
		// 2️⃣ Obtener solo los nombres de los productos usando map()
		System.out.println("La lista de los nombres de los productos:");
		System.out.println(productos.stream()
			.map(n -> n.getNombre()) // Convierte Producto -> String (nombre)
			.toList()); // Se guarda el resultado en una lista
		
		
		// 3️⃣ Calcular el valor total del inventario (precio * stock)
		System.out.println("Valor total del inventario: -> " + productos.stream()
				.map(n -> n.getPrecio() * n.getStock()) // Calcula el valor de cada producto en inventario
				.reduce(0.0, Double::sum) + "€"); // Suma todos los valores
		
		
		// 4️⃣ Ordenar los productos por precio de menor a mayor
		System.out.println("Los productos ordenados por precio:");
		productos.stream()
				.sorted(Comparator.comparingDouble(Producto::getPrecio)) // Ordena por precio
				.forEach(System.out::println); // Imprime los productos ordenados
		
		
		// 5️⃣ Agrupar los productos por categoría
		System.out.println("Los productos agrupados por categoria:");
		Map<String, List<Producto>> agrupacion = productos.stream()
			.collect(Collectors.groupingBy(Producto::getCategoria)); // Agrupa por categoria
		
		
		// Recorre el Map resultante e imprime cada categoría con sus productos
		agrupacion.forEach((categoria, listaProductos) -> {

		    System.out.println("\nCategoria: " + categoria);

		    listaProductos.forEach(System.out::println);

		});
		
		
		// 6️⃣ Obtener el producto más caro usando max()
		Optional<Producto> producto = productos.stream()
			.max(Comparator.comparingDouble(n -> n.getPrecio())); // Busca el producto con mayor precio
		
		
		System.out.println("El producto mas caro");
		System.out.println(producto.orElse(null)); // Si no hay producto devuelve null
		
		
		// 7️⃣ Comprobar si existe algún producto sin stock
		System.out.println("¿Hay algun producto sin stock?\n" + (productos.stream()
				.anyMatch(n -> n.getStock() == 0) ? "Si" : "No")); // Comprueba si algún stock es 0

	}

}

class Producto{
	
	String nombre;
	String categoria;
	double precio;
	int stock;
	
	
	public Producto(String nombre, String categoria, double precio, int stock) {

		this.nombre = nombre;
		this.categoria = categoria;
		this.precio = precio;
		this.stock = stock;
	}

	// Getter y Setter de nombre
	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	// Getter y Setter de categoria
	public String getCategoria() {
		return categoria;
	}

	public void setCategoria(String categoria) {
		this.categoria = categoria;
	}

	// Getter y Setter de precio
	public double getPrecio() {
		return precio;
	}

	public void setPrecio(double precio) {
		this.precio = precio;
	}

	// Getter y Setter de stock
	public int getStock() {
		return stock;
	}

	public void setStock(int stock) {
		this.stock = stock;
	}

	// Representación en texto del producto para imprimirlo fácilmente
	@Override
	public String toString() {
		return "Producto -> " + nombre +
			   "\nCategoria -> " + categoria +
			   "\nP.V.P -> " + String.format("%.2f€", precio) +
			   "\nStock -> " + stock + "\n";
	}

}

Ejercicio 59

Crea una clase llamada Pedido con los siguientes atributos: - int id - List productos Cada pedido contiene una lista de nombres de productos comprados. Crea una lista con varios pedidos de ejemplo (al menos 5 pedidos), donde algunos productos se repitan entre pedidos. Ejemplo de productos: "Portátil", "Ratón", "Teclado", "Monitor", "Mochila", "Tablet", "Auriculares" Realiza las siguientes operaciones usando Streams (mostrando cada resultado por consola): 1️⃣ Obtén una lista con TODOS los productos de todos los pedidos usando flatMap(). 2️⃣ Elimina los productos duplicados usando distinct(). 3️⃣ Ordena los productos alfabéticamente. 4️⃣ Cuenta cuántos productos distintos hay usando count(). 5️⃣ Comprueba si algún pedido contiene "Tablet" usando anyMatch(). 6️⃣ Obtén el primer producto alfabéticamente usando findFirst(). Cada operación debe hacerse con un Stream independiente. No encadenes todo en un único pipeline.

package stream;

import java.util.List;

public class Ejercicio59 {

	public static void main(String[] args) {

		List<Pedido> pedidos = List.of(

			    new Pedido(1, List.of(
			            "Portátil",
			            "Ratón",
			            "Teclado"
			    )),

			    new Pedido(2, List.of(
			            "Monitor",
			            "Ratón",
			            "Auriculares"
			    )),

			    new Pedido(3, List.of(
			            "Tablet",
			            "Mochila",
			            "Ratón"
			    )),

			    new Pedido(4, List.of(
			            "Portátil",
			            "Monitor",
			            "Teclado"
			    )),

			    new Pedido(5, List.of(
			            "Auriculares",
			            "Tablet",
			            "Mochila"
			    ))

			);

		// 1️⃣ Obtener todos los productos de todos los pedidos
		System.out.println("Lista completa de productos:");
		pedidos.stream()
				.flatMap(p -> p.getProductos().stream())
				.forEach(System.out::println);


		// 2️⃣ Eliminar duplicados
		System.out.println("\nProductos sin duplicados:");
		pedidos.stream()
				.flatMap(p -> p.getProductos().stream())
				.distinct()
				.forEach(System.out::println);


		// 3️⃣ Ordenar productos alfabéticamente
		System.out.println("\nProductos ordenados:");
		pedidos.stream()
				.flatMap(p -> p.getProductos().stream())
				.sorted()
				.forEach(System.out::println);


		// 4️⃣ Contar productos distintos
		long total = pedidos.stream()
				.flatMap(p -> p.getProductos().stream())
				.distinct()
				.count();

		System.out.println("\nTotal de productos distintos: " + total);


		// 5️⃣ Comprobar si algún pedido contiene "Tablet"
		boolean hayTablet = pedidos.stream()
				.flatMap(p -> p.getProductos().stream())
				.anyMatch(p -> p.equals("Tablet"));

		System.out.println("\n¿Hay alguna Tablet? " + (hayTablet ? "Si" : "No"));


		// 6️⃣ Obtener el primer producto alfabéticamente
		System.out.println("\nPrimer producto alfabeticamente:");
		String primero = pedidos.stream()
				.flatMap(p -> p.getProductos().stream())
				.sorted()
				.findFirst()
				.orElse(null);

		System.out.println(primero);

	}

}

class Pedido {

	int id;
	List<String> productos;

	public Pedido(int id, List<String> productos) {
		this.id = id;
		this.productos = productos;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public List<String> getProductos() {
		return productos;
	}

	public void setProductos(List<String> productos) {
		this.productos = productos;
	}

	@Override
	public String toString() {
		return "Pedido [id=" + id + ", productos=" + productos + "]";
	}

}

Ejercicio 60

Crea una clase Estudiante con: String nombre int edad double nota Luego crea una lista con al menos 10 estudiantes. Usando Streams, realiza: 1️⃣ Mostrar todos los nombres de estudiantes. 2️⃣ Obtener estudiantes con nota >= 7. 3️⃣ Calcular la nota media. 4️⃣ Obtener el estudiante con la nota más alta. 5️⃣ Ordenar por nota de mayor a menor. 6️⃣ Obtener nombres distintos. 7️⃣ Comprobar: anyMatch() -> si algún estudiante tiene nota 10 allMatch() -> si todos son mayores de 18 noneMatch() -> si ninguno tiene nota menor que 5 8️⃣ Agrupar en "Aprobado" y "Suspenso" usando groupingBy().


package stream;

import java.util.Comparator;
import java.util.DoubleSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Ejercicio60 {

	public static void main(String[] args) {

		// Lista de estudiantes de ejemplo
		List<Estudiante> estudiantes = List.of(

				new Estudiante("Ana", 20, 8.5),
				new Estudiante("Luis", 22, 6.2),
				new Estudiante("Marta", 19, 9.1),
				new Estudiante("Carlos", 23, 4.8),
				new Estudiante("Lucia", 21, 7.3),
				new Estudiante("Pedro", 24, 5.0),
				new Estudiante("Sofia", 20, 9.8),
				new Estudiante("Javier", 22, 3.9),
				new Estudiante("Elena", 19, 7.7),
				new Estudiante("Ana", 21, 6.5)
		);

		// 1️⃣ Mostrar todos los nombres
		System.out.println("Nombres de los estudiantes:");
		estudiantes.stream()
				.map(Estudiante::getNombre) // Obtiene solo el nombre
				.forEach(System.out::println);

		// 2️⃣ Estudiantes con nota >= 7
		System.out.println("\nEstudiantes con nota >= 7:");
		estudiantes.stream()
				.filter(e -> e.getNota() >= 7)
				.forEach(System.out::println);

		// 3️⃣ Calcular la nota media
		DoubleSummaryStatistics stats = estudiantes.stream()
				.collect(Collectors.summarizingDouble(Estudiante::getNota));

		System.out.println("\nNota media de la clase: " + stats.getAverage());

		// Alternativa más simple (más profesional en producción)
		double media = estudiantes.stream()
				.mapToDouble(Estudiante::getNota)
				.average()
				.orElse(0);

		System.out.println("Media calculada con average(): " + media);

		// 4️⃣ Estudiante con la nota más alta
		System.out.println("\nEstudiante con la nota más alta:");
		System.out.println(
				estudiantes.stream()
						.max(Comparator.comparingDouble(Estudiante::getNota))
						.orElse(null)
		);

		// 5️⃣ Ordenar por nota de mayor a menor
		System.out.println("\nEstudiantes ordenados por nota (desc):");
		estudiantes.stream()
				.sorted(Comparator.comparingDouble(Estudiante::getNota).reversed())
				.forEach(System.out::println);

		// 6️⃣ Nombres distintos
		System.out.println("\nNombres distintos:");
		estudiantes.stream()
				.map(Estudiante::getNombre)
				.distinct()
				.forEach(System.out::println);

		// 7️⃣ Validaciones con match operations
		System.out.println("\nValidaciones:");

		System.out.println("¿Algún estudiante tiene nota 10? " +
				(estudiantes.stream().anyMatch(e -> e.getNota() == 10) ? "Si" : "No"));

		System.out.println("¿Todos son mayores de 18? " +
				(estudiantes.stream().allMatch(e -> e.getEdad() >= 18) ? "Si" : "No"));

		System.out.println("¿Ninguno tiene nota menor que 5? " +
				(estudiantes.stream().noneMatch(e -> e.getNota() < 5) ? "Si" : "No"));

		// 8️⃣ Agrupar por resultado académico
		System.out.println("\nAgrupados en Aprobado / Suspenso:");

		Map<String, List<Estudiante>> agrupados = estudiantes.stream()
				.collect(Collectors.groupingBy(
						e -> e.getNota() >= 5 ? "Aprobado" : "Suspenso"
				));

		agrupados.forEach((estado, lista) -> {
			System.out.println("\n" + estado + ":");
			lista.forEach(System.out::println);
		});
	}
}

// Clase Estudiante
class Estudiante {

	String nombre;
	int edad;
	double nota;

	public Estudiante(String nombre, int edad, double nota) {
		this.nombre = nombre;
		this.edad = edad;
		this.nota = nota;
	}

	public String getNombre() {
		return nombre;
	}

	public int getEdad() {
		return edad;
	}

	public double getNota() {
		return nota;
	}

	@Override
	public String toString() {
		return "Estudiante -> " + nombre +
				" | Edad: " + edad +
				" | Nota: " + nota;
	}
}