How to check multiple objects for nullity?

Question

Often, I can see a code constructs like following:

if(a == null || b == null || c == null){
    //...
}

I wonder if there is any widely used library (Google, Apache, etc.) to check against nullity for multiple objects at once, e.g.:

if(anyIsNull(a, b, c)){
    //...
}

or

if(allAreNulls(a, b, c)){
    //...
}

UPDATE:

1. I perfectly know how to write it by myself
2. I know it can be the result of the poor program structure but it's not a case here

3. Let's make it more challenging and replace original example with something like this:

   if(a != null && a.getFoo() != null && a.getFoo().getBar() != null){
       //...
   }
   

UPDATE 2:

I've created a pull request for Apache Commons Lang library to fix this gap:

• Issue: https://issues.apache.org/jira/browse/LANG-781
• PR: https://github.com/apache/commons-lang/pull/108

These will be incorporated in commons-lang, version 3.5:

• anyNotNull (Object... values)
• allNotNull (Object... values)

Duncan

It's easy to write but I rarely encountered such a need. Did you consider the possibility that your data might be poorly structured ? – Candlefish

if you want this kind of direct null check, you can simply create utility by passing it in list and iterate on it. – Sophistry

@Sophistry A list ? A variadic function seems more relevant here. – Candlefish

@DenysSéguret yes that will be better – Sophistry

One problem I could see from this kind of code is that the exception you would be throwing could not actually tell you the name of the parameter that is null when it shouldn't be. – Deadline

About your "more challenging example" and steams: This won't work, either. You are right that the stream itself is evaluated lazily, but the elements you put into the stream are evaluated immediately. See my updated answer. – Cirsoid

There are also some similar questions on the same problem. – Cirsoid

Answer 1

EDIT 2018: As of Apache Commons lang 3.5, there has been ObjectUtils.allNotNull() and ObjectUtils.anyNotNull().

---

No.

None of Apache Commons Lang (3.4), Google Guava (18) and Spring (4.1.7) provide such a utility method.

You'll need to write it on your own if you really, really need it. In modern Java code, I'd probably consider need for such a construct a code smell, though.

Sturtevant

That's a bit weird for me, as there are classes like Objects when they check e.g. for first not null object. But non of them checks for all or non null objects. – Duncan

@KrzysztofWolny Yeah, they are all designed for working with a single possibly-null parameter. I haven't ever seen a method dealing with multiple of them, nor do I think I ever needed it. That would be part of why I think the common libraries don't include them - the demand might be there, but it's probably not very high. But of course, every programmer works differently, so such a method might be exactly what you need. Feel free to file a feature request for your favorite library! – Hemimorphite

@Slantec will consider that, now with GitHub and its pull requests it's so easy :) And Apache has mirrors in GH as well. – Duncan

Actually, there is already a ticket for it in Apache Commons Lang project :) issues.apache.org/jira/browse/LANG-781 – Duncan

@KrzysztofWolny Aha, and it also points out that the Validate class contains almost exactly what you need. Not quite, but almost! :) – Hemimorphite

I know this is an old post, but I see that you've updated your post to include the newest addition of the null check method (cheers for that), so I wanted to see if you still think it's a code smell because I don't see it as such. Null check is a fact of life for Java programmers, and my opinion is that having a clear method name that does that is a clean code. There are many ways to avoid null, but null checks are not always avoidable despite of your best intention. – Abilene

@THISUSERNEEDSHELP I still do. It may be just my coding style, but I like to get rid of nulls in the system as soon as possible by Preconditions.checkNotNull(something, "something"). When checking for multiple nulls, I usually need to know which one of them was null, and that cannot be achieved by a single method. This does not mean that my methods never return null, they sometimes do. But in general this is limited as other constructs are preferred by me. I do not think I had a use for such a method in many years, with the exception of array of objects. – Hemimorphite

Answer 2

In Java 8, you could use Stream.allMatch to check whether all of the values match a certain condition, such as being null. Not much shorter, but maybe a bit easier to read.

if (Stream.of(a, b, c).allMatch(x -> x == null)) {
    ...
}

And analogeously for anyMatch and noneMatch.

---

About your "more challenging example": In this case, I think there is no way around writing a lazy-evaluated conjunction of null-checks, like the one you have:

if (a != null && a.getFoo() != null && a.getFoo().getBar() != null) {
    ...
}

Any of the other approaches, using streams, lists, or var-arg methods, would try to evaluate a.getFoo() before a has been tested not to be null. You could use Optional with map and method pointers, that will be lazily evaluated one after the other, but whether this makes it any more readable is debatable and may vary from case to case (particularly for longer class names):

if (Optional.ofNullable(a).map(A::getFoo).map(B::getBar).isPresent()) {
    ...
}

Bar bar = Optional.ofNullable(a).map(A::getFoo).map(B::getBar).orElse(null);

Another alternative might be to try to access the innermost item, but I have a feeling that this is not considered good practice, either:

try {
    Bar bar = a.getFoo().getBar();
    ...
catch (NullPointerException e) {
    ...
}

Particularly, this will also catch any other NPEs after accessing that element -- either that, or you have to put only the Bar bar = ... in the try and everything else in another if block after the try, nullifying any (questionable) gains in readability or brevity.

---

Some languages have a Safe Navigation Operator, but it seems like Java is not one of them. This way, you could use a notation like a?.getFoo()?.getBar() != null, where a?.getFoo() will just evaluate to null if a is null. You could emulate behavior like this with a custom function and a lambda, though, returning an Optional or just a value or null if you prefer:

public static <T> Optional<T> tryGet(Supplier<T> f) {
    try {
        return Optional.of(f.get());
    } catch (NullPointerException e) {
        return Optional.empty();
    }
}

Optional<Bar> bar = tryGet(() -> a.getFoo().getBar(););

Cirsoid

Oh, that's actually a nice idea. Additionally, Objects::isNull could be used as a predicate. – Hemimorphite

Nice, thanks for this solution. However I would replace x -> x == null with Objects::isNull. It's a bite nicer imo. – Galyak

And a version to check if any is null. if (Stream.of(a, b, b).anyMatch(Objects::isNull)) – Affective

I have found that the need of digging for a value through an objects internal structure to be somewhat of a code smell. To avoid such digging, try to instead have the client to provide the values needed in a more raw format. Compare: public void smell(A a) { if(a != null && a.getFoo() != null && a.getFoo().getBar() != null) ... } vs public void clean(Bar bar) { if(bar != null) ... } – Johnnyjumpup

Answer 3

You could also use something like the following method. It allows you to pass as many parameters as you want:

public static boolean isAnyObjectNull(Object... objects) {
    for (Object o: objects) {
        if (o == null) {
            return true;
        }
    }
    return false;
}

You call it with as many parameters as you like:

isAnyObjectNull(a, b, c, d, e, f);

---

You could do something similar for areAllNull.

public static boolean areAllObjectsNull(Object... objects) {
    for (Object o: objects) {
        if (o != null) {
            return false;
        }
    }
    return true;
}

Note: you could also use the ternary operator instead of if (o == null). The two methods shown here have no error handling. Adjust it to your needs.

Bulter

For areAllNull, just return false if o != null? – Cirsoid

@tobias_k: You are absolute correct. I deleted my comment and edited the code. – Bulter

why do you use Boolean instead of the primitive boolean ? – Hubie

@AlexWien: You can use whatever you like (primitive or object). Change the methods to your needs. Sometimes you have to work with a lot of Boolean objects in an application. By using the Boolean.FALSE / Boolean.TRUE I receive static objects. This way there exist only two in the whole system and the system does not have to create new objects. Each time I call this method or another it will return me the references to the existing ones. – Bulter

@Bulter when you are using primitives the system also does not have to create new objects – Bertrando

@LaurensOp'tZandt I'm absolutely aware of this :-) – Bulter

Answer 4

Objects.requireNonNull

It is possible with help of Objects class and its requireNonNull method.

public static void requireNonNull(Object... objects) {
    for (Object object : objects) {
        Objects.requireNonNull(object);
    }
}

Tufthunter

requireNonNull throws exception. It is better suited for enforcing contracts, rather than testing for nullability, when null is not an exceptional scenario. – Leadership

Answer 5

Apache commons-lang3 since version 3.11 has method ObjectUtils.allNull(Object... values)

ObjectUtils.allNull(obj1, obj2, obj3);

Triangulate

Answer 6

Simply as that:

Stream.of(a,b,c).allMatch(Objects::nonNull)

Examen

Answer 7

I was looking for a solution, but I don't have apache as a dependency yet and it felt silly to me to add it just for the allNonNull method. Here is my plain vanilla java solution using Predicate#and() / Predicate#or() like this:

private static boolean allNonNull(A a) {
    Predicate<A> isNotNull = Objects::nonNull; 
    Predicate<A> hasFoo = someA -> someA.foo != null;
    Predicate<A> hasBar = someA -> someA.foo.bar != null;
    return Optional.ofNullable(a)
        .filter(isNotNull.and(hasFoo.and(hasBar)))
        .isPresent();
}

Note: for the anyNonNull, simply use the or() method instead of and().

When invoked, would give the following output:

    System.out.println(isValid(new A(new Foo(new Bar())))); // true
    System.out.println(isValid(new A(new Foo(null)))); // false
    System.out.println(isValid(new A(null))); // false
    System.out.println(isValid(null)); // false

Class definitions used:

public static class A {
    public A(Foo foo) {
        this.foo = foo;
    }
    Foo foo;
}

public static class Foo {
    public Foo(Bar bar) {
        this.bar = bar;
    }
    Bar bar;
}

public static class Bar { }

Self

Answer 8

You can create a list of you objects and use yourList.contains(null) in it.

List < Object > obList = new ArrayList < Object > ();

String a = null;
Integer b = 2;
Character c = '9';

obList.add(a);
obList.add(b);
obList.add(c);

System.out.println("List is " + obList);

if (obList.contains(null)) {
    System.out.println("contains null");
} else {
    System.out.println("does not contains null");
}

DEMO

Kliment

Nice. Or, to make it actually shorter than the original, use Arrays.asList(a, b, c).contains(null). Won't work for all-null, though... – Cirsoid