Att hantera undantag i Stream API kräver en särskild metod. Till skillnad från traditionella loopar, där ett try-catch-block kan placeras inuti loopens kropp, arbetar streams deklarativt, vilket gör undantagshantering inom dem mer komplex.

Om ett undantag inte hanteras avbryts hela strömbehandlingen. I denna sektion utforskas rätt sätt att fånga och hantera undantag i Stream API.

Problemet med undantagshantering

Anta att vår onlinebutik har en getTotal()-metod som kan kasta ett undantag om orderdata är korrupt eller saknas. Till exempel kan en order laddas från en database där total amount är lagrad som 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;
    }
}

Nu, om någon order har ett totalbelopp mindre än 0, kommer hela Stream API-processen att avslutas med ett undantag.

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

Men det finns ett problem—denna kod kommer inte ens att köras eftersom du inte hanterar de undantag som kan uppstå i getTotal()-metoden. Låt oss därför titta på hur du kan hantera undantag i Stream API.

Hantering av undantag i Stream API

Eftersom try-catch inte kan användas direkt inuti lambdas, finns det flera strategier för undantagshantering i Stream API.

En metod är att fånga undantaget direkt i map() och ersätta det med ett bearbetat resultat:

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();

Inuti mapToDouble() fångas undantaget och en RuntimeException kastas, där det anges vilken användare som orsakade problemet. Denna metod är användbar när det är nödvändigt att omedelbart stoppa exekveringen och snabbt identifiera problemet.

Hoppa över element med fel

Ibland vill du inte stoppa hela processen när ett fel uppstår—du behöver bara hoppa över problematiska element. För att uppnå detta kan du använda filter() med undantagshantering:

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();

Om ett fel uppstår i mapToDouble(Order::getTotal), skulle normalt hela orderströmbehandlingen avbrytas. Men try-catch-blocket inuti filter() förhindrar detta och säkerställer att endast den problematiska användaren utesluts från den slutliga listan.

Undantagshantering med en Wrapper

För att göra vår kod mer robust kan du skapa en wrapper-metod som möjliggör hantering av undantag inuti lambdas samtidigt som de fångas automatiskt.

Java tillåter inte att en Function<T, R> kastar kontrollerade undantag. Om ett undantag uppstår inuti apply(), måste du antingen hantera det inom metoden eller kapsla in det i en RuntimeException, vilket gör koden mer komplex. För att förenkla detta, låt oss definiera ett anpassat funktionellt gränssnitt:

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

Detta gränssnitt fungerar på liknande sätt som Function<T, R> men tillåter att apply() kastar ett undantag.

Nu ska vi skapa en klass ExceptionWrapper med en metod wrap() som konverterar en ThrowingFunction<T, R> till en standard Function<T, R> och accepterar en andra parameter som anger ersättningsvärdet vid ett undantag:

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;
            }
        };
    }
}

Metoden wrap() tar en ThrowingFunction<T, R> och omvandlar den till en standard Function<T, R> samtidigt som undantag hanteras. Om ett fel uppstår loggas meddelandet och det angivna standardvärdet returneras.

Användning i Stream API

Anta att du har en lista med användare i en nätbutik och behöver hitta aktiva användare som har minst tre beställningar värda mer än 10 000. Om en beställning har ett negativt belopp vill du dock inte stoppa strömmen—du returnerar helt enkelt 0 som en indikation på att priset var ogiltigt.

Nu, om en order innehåller ett negativt belopp, så avbryts inte programmet utan loggar istället ett fel och ersätter det med 0,0. Detta gör databehandlingen mer robust och praktisk för verkliga tillämpningar.