Java 8 Optional – Replace your get() calls

Optional class were introduced in order to prevent NullPointerException, but method get() used to retrieve the value inside the Optional might still throw a NoSuchElementException.

Different name, same issue?

Calling get() without checking that value is actually present it’s a bug. So we should always write something like that in order to use get().

But are Optional really meant to be used in this way? No.

Writing block of isPresent/get it’s not so different from writing a classic null check.

Let’s see how we can really benefit from Optional object.

1. Optional orElse example

It returns the value if is present, or the other specified otherwise.

Let’s see an example:

As you can see we haven’t called get() and we’ve made the code easier and more readable compared to the isPresent/get version:

 

2. Optional orElseThrow example

It returns the value if is present, or throws the specified exception otherwise.

 

3. Optional filter example

filter() is useful to specify other conditions on our object. It returns an Optional containing the value if is not empty and satisfy the specified predicate, an empty Optional otherwise.

In this example we want that the name not only is different from null but also that is not empty or made of only empty spaces.

And those are the tests for the null and the empty name:

4. Optional ifPresent example

IfPresent, that it’s different from isPresent, accept a function, a Consumer, and executes it only if the value is present.

So instead of writing something like:

You can write:

or if you prefer:

But let’s have a look to a proper example.

We define a Pojo class, useful also for the following examples, that represents a Loyalty card.

We want to add 3 points to the loyalty card if loyalty card is actually present.

Node: In the following example we’re going to use Mockito to mock LoyaltyCard class. Don’t worry if you are not familiar with Mockito, I’ll add some comments to the code.

 

5. Optional map example

map() it’s a method that we use to transform an input in a different output. In this case nothing changes except that the map operation will be executed only if the value is actually present, otherwise it returns an empty Optional.

In this example we want to retrieve the number of points of our loyalty card if we have it, otherwise number of point will return 0.

6. Optional flatMap example

flatMap() it’s really similar to map() but when output is already an Optional it doesn’t wrap it with another Optional. So instead of having Optional<Optional<T>> if will just return Optional<T>.

Let me clarify it using an example. Let’s define a new class, called Gift.

And let’s define a new method to our LoyaltyCard class that returns an Optional containing the last Gift chosen. Since we are going to mock the result of this method, we don’t really care about its implementation.

We can now create a mocked Gift with name “Biography of Guybrush Threepwood”, put it into an Optional and make getLastGift return it. So if we write:

Output will be an Optional<Optional<Gift>> that is not what we want, so flatMap will unwrap this double level and leave only an Optional<Gift>.

Writing this solution by using isPresent/get would have meant using a nested if: one for check that card was present and another of checking the gift. Harder to read, easier to fail.

7. Optional ifPresentOrElse ?

Unfortunately this is yet to come 🙂 It will be available in Java 9.

Until then we have to write something like:

There are cases in which you are allowed to use get() and isPresent() but use them with a grain of salt.

Resources:

JavaDoc

Short Tutorial By Example

One thought to “Java 8 Optional – Replace your get() calls”

  1. In the case we want a check for NullPointer/NoSuchElement exceptions, why not stuff a default value in the read mutator and be done with it?
    E.g., petName = petNameOptional.get().orElse(“”);

    Thus, ever null/not found.

Leave a Reply