Operaciones finales con Streams: min max

En Java SE, la biblioteca Stream API se incluye en el paquete java.util.stream. Esta biblioteca permite realizar operaciones de procesamiento en colecciones, como listas y conjuntos, de una manera funcional y declarativa. Las operaciones con Streams pueden ser tanto intermedias como terminales, cada una con su propio conjunto de métodos. En este documento, nos centraremos en las operaciones terminales, específicamente en min y max.

Las operaciones finales o terminales en Streams son aquellas que producen un resultado o un efecto secundario. Una vez que se aplica una operación terminal en un Stream, el Stream ya no puede utilizarse más y queda 'consumido'. Las operaciones min y max son operaciones terminales y, como su nombre indica, permiten encontrar el valor mínimo y máximo en un Stream, respectivamente.

Ambos métodos, min y max, requieren un objeto Comparator como argumento para determinar cómo deben compararse los elementos en el Stream. El resultado de ambos métodos es un Optional que puede contener el valor mínimo o máximo si el Stream no está vacío.

Para entender cómo funcionan estas operaciones, primero es esencial comprender cómo funcionan los comparadores. En Java, los comparadores son interfaces que definen un método llamado compare. Este método acepta dos argumentos del mismo tipo y devuelve un número negativo si el primer argumento es menor que el segundo, cero si son iguales y un número positivo si el primero es mayor que el segundo.

Veamos algunos ejemplos de cómo usar min y max con Streams:

import java.util.Arrays;
import java.util.List;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(5, 8, 1, 3, 2);

        // Uso de min
        int min = list.stream()
                .min(Comparator.naturalOrder())
                .orElseThrow();

        System.out.println(min);  // Imprime: 1

        // Uso de max
        int max = list.stream()
                .max(Comparator.naturalOrder())
                .orElseThrow();

        System.out.println(max);  // Imprime: 8
    }
}

En este ejemplo, se utiliza la función Comparator.naturalOrder() que devuelve un comparador que compara los números en su orden natural, es decir, de menor a mayor. Esto significa que min devolverá el número más pequeño de la lista y max devolverá el número más grande.

Se utiliza orElseThrow() al final de las operaciones min y max para lanzar una excepción si el Stream está vacío. Esto es útil para evitar tener que manejar un Optional vacío más adelante en el código.

También se puede usar min y max con objetos personalizados. Sin embargo, necesitarás proporcionar un comparador personalizado. Veamos un ejemplo con una lista de personas:

import java.util.Arrays;
import java.util.List;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        List<Person> list = Arrays.asList(
                new Person("John", 25),
                new Person("Jane", 30),
                new Person("Adam", 20)
        );

        // Uso de min
        Person youngest = list.stream()
                .min(Comparator.comparingInt(Person::getAge))
                .orElseThrow();

        System.out.println(youngest.getName());  // Imprime: Adam

        // Uso de max
        Person oldest = list.stream()
                .max(Comparator.comparingInt(Person::getAge))
                .orElseThrow();

        System.out.println(oldest.getName());  // Imprime: Jane
    }
}

class Person {
    private final String name;
    private final int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

En este caso, se usa Comparator.comparingInt(Person::getAge) para crear un comparador que compara personas por su edad. Esto significa que min devolverá la persona más joven y max devolverá la persona más vieja.

Las operaciones min y max son muy útiles cuando se necesita encontrar el valor mínimo o máximo en una colección de elementos. Sin embargo, es importante recordar que estas operaciones son terminales, lo que significa que después de aplicarlas, el Stream ya no puede utilizarse más.

Como se ha visto, las operaciones con Streams son una herramienta poderosa para el procesamiento de colecciones en Java. Con la combinación de operaciones intermedias y terminales, se pueden realizar tareas complejas de manera eficiente y con código más legible y mantenible. Sin embargo, siempre es crucial recordar las diferencias entre operaciones intermedias y terminales para evitar errores comunes y mantener un flujo de trabajo eficiente.