What's the right way to check null or check exceptions in a chained statement in Java 8?

Question

For example for this code:

List<Class> classes = 
        Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
              .map(className -> Class.forName(className))
              .collect(Collectors.toList());

This code runs fine now. but, assume we have a empty list in stream and we have tons of operations to the stream. It could get NullPointer exceptions and etc. I find it's also hard to try-catch for this kind of statement. What's the right way to handle exception for this?

What? If it's empty, nothing will be applied. Try catch? Where? Why? — Sotirios Delimanolis, Sep 30 '15 at 04:45
what do you mean "empty list in stream"? Your Stream is of String, not List. Did you mean "null string in stream"? — Bohemian, Sep 30 '15 at 05:52

score 8 · Accepted Answer · edited May 23 '17 at 10:28

You do not need to check for nulls. If you have an empty stream all operations will be skipped:

Stream.of("hello")
      .filter(e => "world".equals(e)) // empties the stream
      .foreach(System.out::println); // no NullPointer, no output

Exception handling is possible in mapper:

    List<Class<?>> classes = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
            .map(className -> {
                try {
                    return Class.forName(className);
                } catch (Exception e) {
                    throw new YourRuntimeException();
                }
            })
            .collect(Collectors.toList());

If you want exceptions to be ignored, then I suggest to map to Optionals.

    List<Class<?>> classes = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
            .map(className -> {
                try {
                    return Optional.of(Class.forName(className));
                } catch (Exception e) {
                    return Optional.<Class<?>>empty();
                }
            })
            .filter(Optional::isPresent) // ignore empty values
            .map (Optional::get) // unwrap Optional contents
            .collect(Collectors.toList());

Please also have a look at How can I throw CHECKED exceptions from inside Java 8 streams? for a more detailed discussion about Class.forName in combination with java 8 streams.

Neither is `=>`. Note that the three steps, mapping to `Optional`, filtering via `Optional.isPresent`, and unwrapping the `Optional` are unnecessarily complicated. A single `flatMap` can do the operation. — Holger, Sep 30 '15 at 09:02
`filter` and `map` in your last example could be replaced by `flatMap(Optional::stream)` (if Java >= 9). — MC Emperor, Dec 22 '22 at 08:10

score 4 · Answer 2 · answered Sep 30 '15 at 09:00

Your question is a bit strange. You are claiming “This code runs fine now” whereas it should generate compile-time errors as you are not handling the checked exception declared by Class.forName. Further you are talking about empty lists, but in your code, no lists are involved. The same applies to your reference to NullPointerException as your code does not produce null at any place.

Most probably, you are talking about a code which catches the ClassNotFoundException and handles it by returning null. You should never do this. If you want to filter out failures, you may do it this way:

List<Class<?>> classes = 
    Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
        .flatMap(className -> {
                try {
                    return Stream.of(Class.forName(className));
                } catch (ClassNotFoundException ex) {
                    // recommended: insert logging statement here
                    return Stream.empty();
                }
            })
        .collect(Collectors.toList());

This way, no element will be generated in the case of an exception and you don’t have to do additional error handling downstream.

score 0 · Answer 3 · answered Dec 22 '22 at 08:03

We can use try-with-resources also,

try(List<Class> classes = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String"))
{
 List<Class> classes = Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")        
              .map(className -> Class.forName(className))
              .collect(Collectors.toList()); 
}

should add throws Exception to handle

score 0 · Answer 4 · answered Dec 22 '22 at 08:25

I wasn't sure what you meant by "have a empty list in stream", but if you wanted to safely handle possibility of nulls in the Stream, you could use:

List<Class> classes =
Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String", null)
    .filter(Objects::nonNull)
    .map(className -> {
      try {
        return Class.forName(className);
      } catch (ClassNotFoundException e) {
        System.out.println("No class found for: " + className);
        return null;
      }
    })
    .filter(Objects::nonNull)
    .collect(Collectors.toList());

What's the right way to check null or check exceptions in a chained statement in Java 8?

4 Answers4