How to check if is null and if has a specific value using Optional in java?

Question

Assume that I have this code in my project:

public List<T> getAll(Integer parameter) {
    if(parameter != null && parameter > -1) {
        // do something here
    }
}

My question is: how can I do the checking with Optional instead of using if, or if there is another thing I could use?

Answer 1

Optional's design was inspired by monads known from the world of Functional Programming. In such case, it could look like this:

public List<T> getAll(Integer parameter) {

    return Optional.ofNullable(parameter)
      .filter(p -> p > -1)
      .map(p -> *some modification*) //this line is optional
      .orElseGet(() -> *some default value, probably an empty list*)
}

In such case, condition checking is performed in the filter method. If a given Predicate is not matched, the underlying Optional will be empty.

If you want to perform an operation on the underlying value, use map method by providing it with a Function that should be applied to the element wrapped by the Optional.

At the end, you can simply perform some action using ifPresent(), thrown an exception orElseThrow or simply return a default value with orElse or orElseGet. Keep in mind that orElseGet accepts a Supplier instance which makes it evaluate the default value lazily.

If you want to dig deeper, check out @stuart-marks talk from Devoxx: https://www.youtube.com/watch?v=Ej0sss6cq14&t=2767s

In your case, there might be no need for an Optional at all. Just two methods. One with the parameter and the other without.

Answer 2

You should not use Optional for such a case

As Stuart Marks states in Optional - The Mother of All Bikesheds:

Rule #4: It's generally a bad idea to create an Optional for the specific purpose of chaining methods from it to get a value.

This creates a useless overhead without any improvement for code readability and maintainability. You should thus not wrap your parameter into an optional.

and

Rule #6: Avoid using Optional in fields, method parameters and collections.

Avoid using Optional in method parameters

• it doesn't really work for making parameters optional

• forces call sites to create Optionals for everything:

  myMethod(Optional.of("some value"));

  myMethod(Optional.empty());

See also Why should Java 8's Optional not be used in arguments.

Answer 3

Use Optional<Integer>

public List<T> getAll(Integer paramter) {
    return Optional.ofNullable(parameter)
      .filter(p -> p > -1);
}

The Optional<> is just an implementation of Optional pattern. The useful methods is also Optional<T>#orElse(T default) which sets the value to default in case there was a null,

If you already got interested but still can't answer your doubts, please ask for clarification in comments. I'll respond asap.

Answer 4

You need to be clear about what you expect of your method. Possibilities:

• You want it to keep working as before, and handle the case where the client supplies a null
• You want to change the method to accept Optional<Integer> as its parameter. The "no nulls" way, is to do this, and simply not accommodate callers who supply null -- if they get a NullPointerException, it's their own fault because they broke the rules.

You don't have to work with streams or lambdas to work with Optional (although of course, you can).

You could simply write:

public List<T> getAll(Optional<Integer> maybeParameter) {
    if(maybeParameter.isPresent() && maybeParameter.get() > -1) {
        // do something here
    }
}

Look at Optional's other methods in JavaDoc, to see how else it can be used.

If you didn't want to change the signature of your method, you could use Optional.ofNullable() to turn an Integer into an Optional<Integer>:

public List<T> getAll(Integer parameter) {
    Optional<Integer> maybeParameter = Optional.ofNullable(parameter);
    // work with the Optional here as before...
}

However I question the value of doing this here. If your API accepts nulls, then handling it with Optional "behind the scenes" doesn't provide an advantage.

I feel the best use of Optional is to expose it as part of your API. If a parameter is optional, declare it as Optional rather than handling null (or better, use method overloading, so they don't have to pass anything at all). If a return value might not be set, make the return type Optional, rather than ever returning null.

Answer 5

import java.util.Optional;

public class ExampleNullCheck{

    public static void main(String args[])
    {
        Integer a = null;
        Optional<Integer> checkInt = Optional.ofNullable(a);
        System.out.println(checkInt.isPresent());
    }//main

}//class