What's the best way to avoid null using inside lambda using Java 8?

Question

I have this piece of code and i'm trying to figure out what's the best way to avoid null pointer exception using Java 8?

promotion.forEach(item ->
    item.getDiscount().getPromotions().forEach(promotion -> {
        // logic code here
    })
);

Where is the potential NPE? What's the connection to lambdas? — shmosel, Dec 12 '16 at 20:54
The class `Optional` was specifically included in the Java Platform Library to handle cases in which `null` values can occur in the streams. — scottb, Dec 12 '16 at 21:00
Seems like this question can generalize to any use of iterators... it's not limited to lambdas. — martin jakubik, Dec 12 '16 at 21:01

Adriaan Koster · Answer 1 · 2016-12-13T10:19:51.237

The best way to avoid NullPointerExceptions is to avoid null values. In your example, make sure all the methods never return null.

Instead of returning null you have several options:

throw an exeption. For example if a method's input causes a division by zero you can throw an exception instead of returning null.
return an empty Optional. For example a method returning String could be changed to return Optional<String>. When there is no String to return, you return Optional.empty()
return an empty Collection (e.g. when the result type is a List, return an empty List if there are no results found, rather than returning null)
return a custom result type, capable of reflecting the result. For example when doing validation you could return a ValidationResult representing success/failure and error messages instead of returning a null error message when there is no error

score 3 · Accepted Answer · edited May 16 '19 at 10:54

3

promotion.stream()
    .map(item->item.getDiscount()).filter(Objects::nonNull)
    .map(discount->discount.getPromotions()).filter(Objects::nonNull)
    .forEach(innerPromotion->{//logic code});

You can filter all the null elements out before you use them in the logic code so that only the non-null elements have the logic code run.

edited May 16 '19 at 10:54

Lothruin

3
3

answered Dec 12 '16 at 20:56

Steven Waterman

611
4
17

Is the .filter(discount - discount != null) necessary? Doesn't .map(discount->discount.getPromotions()) do the job? – Vipercold Dec 12 '16 at 21:05
1

If item.getDiscount() returned null then you'd get a NPE when doing .map(discount.getPromotions()) unless you filter out the null discount values first – Steven Waterman Dec 12 '16 at 21:07
2

I would argue that the Discount class should be designed to *never* return null from a collection method like getPromotions; when there are zero promotions, always return an empty collection. – VGR Dec 12 '16 at 22:18
Perfect answer so that foreach doesn't throw null pointer exception. – AdityaKapreShrewsburyBoston Mar 07 '21 at 20:53

score 3 · Answer 3 · 2016-12-12T21:13:53.600

3

Are you thinking about something like Optional :

item.getDiscount().getPromotions().stream().forEach(promotion ->     
    Optional.ofNullable(promotion).ifPresent(p -> {
        // logic code 
    } )
);

EDIT : if item.getDiscount() may be null then you can try :

Optional.ofNullable(item.getDiscount()).ifPresent(d -> 
    d.getPromotions().stream().forEach(promotion ->     
        Optional.ofNullable(promotion).ifPresent(p -> {
            // logic code 
        } )
    )
);

edited Dec 12 '16 at 21:13

answered Dec 12 '16 at 21:03

on .getPromotions() it will raise NPE don't? – Vipercold Dec 12 '16 at 21:08

What's the best way to avoid null using inside lambda using Java 8?

3 Answers3