Elegant Handling of Exceptions in Java 8 Lambda Streams Using Vavr's Try

Java 8 introduced Lambda‑Streams, enabling more concise and functional‑style code, but when an exception occurs the stream terminates and, for checked exceptions, developers must use try‑catch blocks, which harms readability.

Problem example:

package com.renzhikeji.demo;

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

public class Demo {
    public static void main(String[] args) {
        List
list = Arrays.asList(1, 2, 0, 3, 5, 6, 7, 8);
        List
result = list.stream().map(t -> {
            if (t == 0) {
                return t / 0; // will throw ArithmeticException
            }
            return t;
        }).collect(Collectors.toList());
        System.out.println(result);
    }
}

Running this code throws an exception and the subsequent processing stops.

To keep the stream alive while handling exceptions elegantly, the article recommends using Vavr's Try construct.

Solution example 1 (using Try to wrap each element):

package com.renzhikeji.demo;

import io.vavr.control.Try;
import java.util.Arrays;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List
list = Arrays.asList(1, 2, 0, 3, 5, 6, 7, 8);
        List
> tryList = list.stream()
            .map(t -> Try.of(() -> {
                if (t == 0) {
                    return t / 0;
                }
                return t;
            }))
            .toList();
        for (Try
aTry : tryList) {
            if (aTry.isSuccess()) {
                System.out.println(aTry.get());
            } else {
                aTry.getCause().printStackTrace();
            }
        }
    }
}

The output shows that even when an exception occurs, the rest of the stream continues processing.

Solution example 2 (chaining Try operations):

package com.renzhikeji.demo;

import io.vavr.control.Try;

public class Demo {
    public static void main(String[] args) {
        Try
aTry = Try.of(() -> 0)
            .map(t -> 10 / t) // no try‑catch needed, subsequent steps still run
            .andThen(System.out::print)
            .onFailure(e -> e.printStackTrace()) // invoked on failure
            .recover(ArithmeticException.class, 0); // provide default for specific exception
        System.out.println(aTry);
    }
}

This chain handles the division‑by‑zero gracefully, prints the stack trace, and substitutes a default value, allowing the program to proceed.

Conclusion: Java 8 does not provide built‑in elegant exception handling for streams, but using Vavr's Try wrapper offers a clean, functional way to manage both checked and unchecked exceptions without breaking the stream's flow.