Avoiding Null Pointer Exception in "for" statement

Question

In my code I usually use this approach to avoid NullPointerExceptions in for statements when a List is null:

if (myList != null && myList.size() > 0) {
    for ( MyObj obj : myList ) {
        System.out.println("MyObjStr: "+obj);
    }
}

Is there another way to do the same without write the "if" statement, but using the same "for" statement?

Answer 1

The check for the size is not needed. Your for-loop will not execute if is there are no objects in the list.

The check for null is only needed, when you are not sure about the object's state. But when using your own objects (nothing given from outside via arguements e.g.) then there is no need for the null check.

See Avoiding “!= null” statements in Java? for a brilliant explanation why unexperienced developers often exaggregate with null checks.

Answer 2

An elegant way to do this, can be found in a similar post. using

for( Object o : safe( list ) ) {
   // do whatever 
 }

public static List safe( List other ) {
    return other == null ? Collections.EMPTY_LIST : other;
}

That beeing said, it's a good practice to have your methods returning empty Arrays instead of null. For example you can return

return Collections.EMPTY_LIST;

in every catch block.

This way you will loop in them safely, and when you get a NPE, you'll know that something is wrong with your code, not your data. In this context, as @Joffrey said, the NPE will be really welcome

Answer 3

First of all, the size check is not needed. The for loop is skipped if the size is 0.

The null check is a bit more contextual. In general you don't want to just "avoid NPE". NPE is a good way to notice programming mistakes, so you have to be careful about what needs to be null-checked. Many programmers put null-checks everywhere defensively, because they don't trust the API contracts anymore.

• If you have an NPE with something that has no reason to be null, then you have done something wrong earlier (here it would be because your collection variable is not initialized). You don't want to hide that, you want it to explode at your face, so you can fix it right away (Fail fast principle).

• If null is a possible (and meaningful) value for a variable (or if the value comes from an external source), then it needs to be null-checked. However, you have to handle that case, do not just skip the code that produces NPE. If you just skip it, then later code is no more safe than the current piece, and null-checks will be needed again for the same variable.

@ifLoop provided a very good link to another post about this topic, so I copy it here since my answer is accepted: Avoiding “!= null” statements in Java?

Answer 4

Well you can do it one line but with a readability loss :

for ( MyObj obj : (myList == null ? new ArrayList<MyObj>() : myList) ) {
    System.out.println("MyObjStr: "+obj);
}

Answer 5

There is another possibility to avoid passing NULL into our for (forEach) loop - we can use isNotEmpty(Collection coll) method from CollectionUtils library before.

Example:

if (CollectionUtils.isNotEmpty(someCollection)) {
    for (Item item: someCollection) {
    ...
    }
}

OR:

if (CollectionUtils.isNotEmpty(someCollection)) {
    someCollection.forEach(...);
}

Answer 6

There are a lot of cases when you are supposed to do a mapping exercise for incoming DTO into another Object. Sending empty collections instead of null can be a waste of traffic, and even nulls are excluded by using mapper.setSerializationInclusion(Include.NON_NULL); or even mapper.setSerializationInclusion(Include.NON_EMPTY);

That said, if you need to do something like:

Collection<Dto> dtos = null;
for(Dto dto: dtos) {
   //doSomething
} 

You have to protect with if(ok, but I prefer another way) or stick to NullObject idiom(good):

Collection<Dto> safeDtos = Optional.ofNullable(dtos).orElse(Collections.emptyList());
for(Dto dto: safeDtos) {
   //doSomething
} 

Or the same but for streams:

Optional.ofNullable(dtos).orElse(Collections.emptyList()).stream()
    .map(this::doSomething)
    .collect(Collectors.toList());

Also, try not to leak DTOs in any downstream code except that mapping exercise. You should have a border of protection between DTO and the rest of your code.

DTO -> Mapping -> Domain Object(or another intermediate object which is NPE save and maybe has enums instead of strings, etc) -> Rest of your code.