El manejo de excepciones en la Stream API requiere un enfoque especial. A diferencia de los bucles tradicionales, donde se puede colocar un bloque try-catch dentro del cuerpo del bucle, las streams operan de manera declarativa, lo que hace que el manejo de excepciones dentro de ellas sea más complejo.

Si una excepción no se maneja, interrumpe todo el procesamiento del stream. En esta sección, se explorará la forma adecuada de capturar y manejar excepciones en la Stream API.

El problema del manejo de excepciones

Supongamos que nuestra tienda en línea tiene un método getTotal() que puede lanzar una excepción si los datos del pedido están corruptos o faltan. Por ejemplo, un pedido podría cargarse desde una base de datos donde el monto total se almacena como null.

class Order {
    private final double total;

    public Order(double total) {
        this.total = total;
    }

    public double getTotal() throws Exception {
        if (total < 0) {
            throw new IllegalArgumentException("Invalid order total");
        }
        return total;
    }
}

Ahora, si algún order tiene un total menor que 0, todo el proceso de la Stream API finalizará con una excepción.

 List<User> premiumUsers = users.stream()
                .filter(User::isActive)
                .filter(user -> user.getOrders().stream()
                        .filter(order -> order.getTotal() >= 10000)
                        .count() >= 3)
                .toList();

Pero existe un problema: este código ni siquiera se ejecutará porque no se están gestionando las excepciones que pueden ocurrir en el método getTotal(). Por lo tanto, veamos cómo se pueden gestionar excepciones en la Stream API.

Manejo de excepciones en Stream API

Dado que try-catch no puede utilizarse directamente dentro de lambdas, existen varias estrategias para el manejo de excepciones en Stream API.

Un enfoque consiste en capturar la excepción directamente dentro de map() y reemplazarla con un resultado procesado:

List<User> premiumUsers = users.stream()
        .filter(User::isActive)
        .filter(user -> user.getOrders().stream()
                .mapToDouble(order -> {
                    try {
                        return order.getTotal();
                    } catch (IllegalArgumentException e) {
                        throw new RuntimeException("Error in user's order: " + user, e);
                    }
                })
                .filter(total -> total >= 10000)
                .count() >= 3)
        .toList();

Dentro de mapToDouble(), se captura la excepción y se lanza una RuntimeException, especificando qué usuario causó el problema. Este enfoque resulta útil cuando es necesario detener la ejecución de inmediato e identificar rápidamente el problema.

Omitir elementos con errores

En ocasiones, no se desea detener todo el proceso cuando ocurre un error; simplemente es necesario omitir los elementos problemáticos. Para lograr esto, se puede utilizar filter() con manejo de excepciones:

List<User> premiumUsers = users.stream()
        .filter(User::isActive)
        .filter(user -> {
            try {
                return user.getOrders().stream()
                        .mapToDouble(Order::getTotal)
                        .filter(total -> total >= 10000)
                        .count() >= 3;
            } catch (Exception e) {
                return false; // Skip users with problematic orders
            }
        })
        .toList();

Si ocurre un error en mapToDouble(Order::getTotal), normalmente se detendría todo el procesamiento del flujo de pedidos. Sin embargo, el bloque try-catch dentro de filter() evita esto, asegurando que solo el usuario problemático sea excluido de la lista final.

Manejo de Excepciones con un Wrapper

Para hacer nuestro código más robusto, se puede crear un método wrapper que permita manejar excepciones dentro de lambdas mientras las captura automáticamente.

Java no permite que un Function<T, R> lance excepciones comprobadas. Si ocurre una excepción dentro de apply(), se debe manejar dentro del método o envolverla en un RuntimeException, lo que hace el código más complejo. Para simplificar esto, definamos una interfaz funcional personalizada:

@FunctionalInterface
interface ThrowingFunction<T, R> {
    R apply(T t) throws Exception;
}

Esta interfaz funciona de manera similar a Function<T, R>, pero permite que apply() lance una excepción.

Ahora, creemos una clase ExceptionWrapper con un método wrap() que convierte un ThrowingFunction<T, R> en un Function<T, R> estándar y acepta un segundo parámetro que especifica el valor alternativo en caso de una excepción:

class ExceptionWrapper {
    // Wrapper for `Function` to handle exceptions
    public static <T, R> Function<T, R> wrap(ThrowingFunction<T, R> function, R defaultValue) {
        return t -> {
            try {
                return function.apply(t);
            } catch (Exception e) {
                System.out.println(e.getMessage());
                return defaultValue;
            }
        };
    }
}

El método wrap() toma un ThrowingFunction<T, R> y lo convierte en un Function<T, R> estándar mientras gestiona las excepciones. Si ocurre un error, registra el mensaje y devuelve el valor predeterminado especificado.

Uso en Stream API

Suponga que tiene una lista de usuarios en una tienda en línea, y necesita encontrar usuarios activos que tengan al menos tres pedidos con un valor superior a 10,000. Sin embargo, si un pedido tiene un importe negativo, no desea detener el stream—simplemente devuelve 0 como indicación de que el precio era inválido.

Ahora, si un order contiene una negative amount, el program no se detiene, sino que simplemente registra un error y lo reemplaza por 0.0. Esto hace que el data processing sea más robust y practical para el real-world use.