Over a million developers have joined DZone.

Java 8 Optional is Not Just for Replacing a null Value

· Java Zone

Microservices! They are everywhere, or at least, the term is. When should you use a microservice architecture? What factors should be considered when making that decision? Do the benefits outweigh the costs? Why is everyone so excited about them, anyway?  Brought to you in partnership with IBM.

In Java 8, you can return an Optional instead of return null; as you might do in Java 7.  This may or may not make a big difference depending on whether you tend to forget to check for null or whether you use static code analysis to check to nullalbe references.

However, there is a more compelling case which is to treat Optional like a Stream with 0 or 1 values.

Simple Optional Use Case

In the old days of Java 7 you would write something like
String text = something();
if (text != null) {
With Optional you can instead write
Optional text = something();
if (text.isPresent()) {
    String text2 = text.get();
However, if you are being paranoid you might write.
Optional text = something();
if (text != null && text.isPresent()) {
    String text2 = text.get();
If you have NullPointerException errors often in your project Optional might help, but otherwise it's not looking like it helps much. 

A more complex example

Lets instead consider this example
static String getFirstSecondThird(Nested nested) {
    try {
          return ((Contained2) nested.first.second).get(0).third;
    } catch (NullPointerException | 
             ClassCastException | 
             IndexOutOfBoundsException ignored) {
          return null;
This is really ugly.  Instead of catching exceptions, you can build a long list of condition check but it becomes really hard to see what you are trying to do.
Optional allows you to handle all the possible error conditions without an Exception or nested if/else logic.
static Optional getFirstSecondThird(Optional nested) {
    return nested // could be non-present
            .map(x -> x.first) // could be null
            .map(x -> x.second) // could be null
           // could be another type
            .map(x -> x instanceof Contained2 ? (Contained2) x : null)
            .map(x -> x.list) // could be null
            .filter(x -> !x.isEmpty()) // could be empty
            .map(x -> x.get(0)) // could be null
            .map(x -> x.third); // could be null.
What we get is a series of mappings and filters which only progress if the value is non-null and present. If any value is null, or a filter is not true, the whole result is "not present".


Using Optional can be a powerful way to navigate a complex data structure in a safe way.  The purpose of lambdas is to reduce boiler plate code, and in the case it avoids all the checks or errors you have.


For your interest, here is the classes I used in the example above.
static class Nested {
    Contained first;
static class Contained {
    IContained2 second;
interface IContained2 {
static class Contained2 implements IContained2 {
    List list;
static class Data {
    String third;

Discover how the Watson team is further developing SDKs in Java, Node.js, Python, iOS, and Android to access these services and make programming easy. Brought to you in partnership with IBM.


Published at DZone with permission of Peter Lawrey, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

The best of DZone straight to your inbox.

Please provide a valid email address.

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}