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

Looks like you are looking for something like:

list.sort(Comparator.comparing(Entity::getParent, 
                               Comparator.nullsLast(Integer::compareTo)));

All the elements with parent null will be put at the end and the rest will be sorted by their parent.

This code doesn't make sense. You are executing the same Stream pipeline twice, and each time you generate an entire List when you only need the first element of that List.

You can use findFirst to get the first element of the Stream.

EDIT :

After testing my original answer, it turned out it doesn't work. findFirst() throws a NullPointerException if the first element is null.

You can avoid that by setting the default value before calling findFirst() :

ca.getInterviews().stream()
                  .map(Interview::getAgency)
                  .map(Agency::getAgencyName)
                  .map(s->s!=null?s:"") // this will replace null with ""
                  .firstFirst()
                  .get();

The issue was: I was using .isEmpty() on a null object. I had to use StringUtils.isEmpty() method:

services = services.stream()
        .filter(service -> (StringUtils.isEmpty(service.getType()) || service.getType().equals(type)))
        .collect(Collectors.toList());

You shouldn't call get() on your Optionals - and when you use Optional.map you have a nice way to wrap a null result from a Map get into another Optional:

Optional<PTerms> dealPricingTerms = dDetails
        .getDealCommits().map(c -> c.get(cNumber))
        .flatMap(dc -> dc.getPTerms())
        .map(l -> l.stream())
        .flatMap(s ->
                s.filter(dealPricingTerm ->
                        tMonth.equals(dealPricingTerm.getDeliveryPeriod()))
                        .findFirst());