Is there an elegant way to unwrap an object wrapped in 2 nested Optionals?

Question

Consider these two classes

class EmailService {
    public Optional<String> getEmailAlias(String email);
}

enum Queue {
    public static Optional<Queue> fromEmailAlias(String alias);
}

The implementation of the above methods is not important to the question so I have left that out for simplicity.

I want to do this:

emailService.getEmailAlias("john@done")
    .map(Queue::fromEmailAlias)
    .ifPresent(queue -> { 
        // do something with the queue instance, oh wait it's an Optional<Queue> :(
    });

However, this does not work because queue is of type Optional<queue> (the same type as returned by Queue::fromEmailAlias), so I have this instead:

emailService.getEmailAlias("john@done")
    .map(Queue::fromEmailAlias)
    .ifPresent(q-> { 
            q.ifPresent(queue -> {
                // do something with the queue instance
            }
    });

Kind of ugly imho.

Changing the signature of

public static Optional<Queue> fromEmailAlias(String alias);

to

public static Queue fromEmailAlias(String alias);

is a quick fix, but that would also affect my code in other places which need Optional<Queue>.

Is there a nice way to unwrap this nested Optional?

Answer 1

You need to apply flatMap:

emailService.getEmailAlias("john@done")
            .flatMap(Queue::fromEmailAlias)
            .ifPresent(queue -> { 

             });