How can I collect results of a Java stream operation that throws exceptions in a concise manner?

Question

Have a look at the following snippet that tries to convert a list of strings into a list of class objects:

public static List<Class<?>> f1(String... strings) {
    return
        Stream.of(strings)
        .map(s -> {
            try {
                return Class.forName(s);
            }
            catch (ClassNotFoundException e) {
                System.out.println(e.getMessage());
            }
            return null;
        })
        .collect(Collectors.toList());
}

Because of the way Java handles checked exceptions in streams (as has been discussed at length here - where I also blatantly stole my example snippet from), you have to have the additional return statement after the try-catch block. This will result in an unwanted null reference being added to the result of type List<Class>.

To avoid this extra null reference, I came up with the following function, achieving a better result with a plain old procedural loop:

public static List<Class<?>> f2(String... strings) {
    List<Class<?>> classes = new ArrayList<>();
    for (String s : strings) {
        try {
            classes.add(Class.forName(s));
        }
        catch (ClassNotFoundException e) {
            // Handle exception here
        }
    }
    return classes;
}

Does this observation allow me to draw a conclusion in the form of a best-practice advice, that could be expressed like the following?

If you need to call a function that throws an exception inside a stream and you cannot make use of stream.parallel(), better use a loop, because:

1. You'll need the try-catch block anyway (notwithstanding the tricky solutions involving some kind of wrapper around the throwing function provided in the aforementioned discussion)

2. Your code will not be less concise (mainly because of 1.)

3. Your loop will not break in case of an exception

What do you think?

Answer 1

As @Patrick wrote, you could filter your null classes. Just add a filter after the map in your stream:

 .filter(Objects::nonNull)
 .collect(Collectors.toList());

Answer 2

You can do this without introducing elements which you have to filter in a subsequent step:

public static List<Class<?>> f1(String... strings) {
    return Arrays.stream(strings)
        .flatMap(s -> {
            try { return Stream.of(Class.forName(s)); }
            catch(ClassNotFoundException e) { return null; }
        })
        .collect(Collectors.toList());
}

Still, this isn’t more concise than a loop solution.

But it should be noted that this has nothing to do with checked exceptions. You want to continue in the exceptional case, omitting the failed element. That always requires you to catch the exception to implement this alternative behavior (the default would be to propagate the exception to the caller), whether the exception is checked or unchecked. The checked case has the advantage of reminding you that you have to do this.

In other words, the Stream API does not allow you to implement the behavior of propagating checked exceptions to the caller in a simple way, but that’s not what you want here anyway. If Class.forName(String) was designed to throw unchecked exceptions only, omitting the try … catch block in map would cause the entire operation to abort in the exceptional case by relaying the exception to the caller. But, as said, that’s not what you want here.