Handling null pointers and throwing exceptions in streams

Question

Let's consider a Parent class which contains only one Integer attribute. I created 6 objects of parent class and with one null variable. Then I added these objects to a list.

I want to retrieve the corresponding object by the value of Integer attribute. I used Java 8 Streams for it.

Predicate<Parent> predicate = e -> e.getId() == 100; // sample attribute value
result = list.stream().filter(predicate).collect(Collectors.toList());

But I got NullPointerException, so I edited the code:

list.stream().filter(h -> h!=null).filter(predicate).collect(Collectors.toList());

But I want to throw an exception if any of the object is null. If no objects in the list is null, then I want to retrieve the corresponding object from list.

How can I achieve this using a single statement using Java 8 Streams?

Answer 1

JB Nizet answer is okay, but it uses map only for its side effects and not for the mapping operation, which is kind of weird. There is a method which can be used when you are solely interested in the side effects of something, such as throwing an exception: peek.

List<Parent> filtered = list.stream()
    .peek(Objects::requireNonNull)
    .filter(predicate)
    .collect(Collectors.toList());

And if you want your own exception just put a lambda in there:

List<Parent> filtered = list.stream()
    .peek(p -> { if (p == null) throw new MyException(); })
    .filter(predicate)
    .collect(Collectors.toList());

---

Note about non exhausted streams

Note that, regardless of if you use map or peek, you have to make sure that the stream is consumed in its entirety for all the elements to be checked! Otherwise the exception might not be thrown even if there are null elements.

Examples where all elements might not be checked:

• limit is used.
• allMatch is used.
• The stream is filtered BEFORE the null check pipeline stage.

---

Checked Exceptions

If your exception is checked you can either check for null beforehand, if you don't mind traversing the list twice. This is probably best in your case, but might not always be possible.

if (list.contains(null)) throw new MyCheckedException();

You could also throw an unchecked exception in your stream pipeline, catch it and then throw the checked one:

try {
    ...
        .peek(p -> { if (p == null) throw new MyException(); })
    ...
} catch (MyException exc) {
    throw new MyCheckedException();
}

Answer 2

Let’s start with the simplest solution:

if(list.contains(null)) throw new MyException();
result = list.stream().filter(predicate).collect(Collectors.toList());

If you suspect the list to contain nulls and even have a specialized exception type to flag this condition, a pre-check is the cleanest solution. This ensures that such condition doesn’t silently remain if the predicate changes to something that can handle nulls or when you use a short-circuiting stream operation that may end before encountering a subsequent null.

If the occurrence of null in the list still is considered a programming error that shouldn’t happen, but you just want to change the exception type (I can’t imagine a real reason for this), you may just catch and translate the exception:

try {
    result = list.stream().filter(predicate).collect(Collectors.toList());
}
catch(NullPointerException ex) {
    if(list.contains(null)) // ensure that we don’t hide another programming error
        throw new MyException();
    else throw ex;
}

This works efficient under the assumption that null references do not occur. As said, if you suspect the list to contain null you should prefer a pre-check.

Answer 3

::map vs ::peek

Use Stream#map and NEVER USE Stream#peek method in production code. As Javadoc says peek was mainly to support debugging ...where the stream implementation is able to optimize away..., the action will not be invoked for those elements. REF: javadoc

java.utils.Objects#requireNonNull

  list.stream()
      .map(Objects::requireNonNull)
      .filter(predicate)

This code clearly separates the validation part and filter part. It will contain "requireNonNull" frame in the exception call stack. Although, by java.util design, it'll rise NPE exceptoin type. REF: javadoc. SRC: openjdk

---

requireNonNull with a static message

  list.stream()
      .map(item -> requireNonNull(item, "Null item in the list."))
      .filter(predicate)

import static java.util.Objects.requireNonNull;

REF: javadoc. SRC: openjdk

---

requireNonNull with a custom message supplier

  list.stream()
      .map(item -> requireNonNull(item, () -> "Expected non-null items. Was: " + list))
      .filter(predicate)

REF: javadoc. SRC: openjdk

---

custom validator

  list.stream()
      .map(this::requireItemNonNull)
      .filter(predicate)
      ...


private Parent requireItemNonNull(Parent item) {
  if (null == item) throw new IllegalStateException("Expected: non null items. Was: " + this.list);
  return item;

---

validate all

If you only need to validate all items, use a collector at the end. E.g. toArray as stream postpones actual iteration until the "collect" time:

  list.stream()
      .map(this::validateItemNonNull)
      .toArray();

Answer 4

Function<Parent, Parent> throwingIdentity = p -> {
    if (p == null) {
        throw new MyException();
    }
    return p;
};

List<Parent> filtered = 
    list.stream()
        .map(throwingIdentity)
        .filter(predicate)
        .collect(Collectors.toList());