	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Java 8 Features > Stream API > Java 8 Optional Chaining with map and flatMap

Java 8 Optional Chaining with map and flatMap

Author: Venkata Sudhakar

Optional is a container object in Java 8 that may or may not hold a value. Its purpose is to make the possibility of a missing value explicit in the API, forcing the caller to handle it rather than accidentally calling a method on null. The real power of Optional is not just wrapping a value - it is the ability to chain transformations using map() and flatMap() so you can safely navigate nested objects without a chain of null checks.

map() transforms the value inside an Optional if one is present, returning a new Optional with the result. If the Optional is empty, map() does nothing and returns an empty Optional. flatMap() works the same way but is used when the transformation function itself returns an Optional, preventing you from ending up with Optional of Optional. orElse() and orElseGet() extract the final value, providing a default if the Optional is empty.

The below example shows how Optional chaining replaces nested null checks when navigating an Order to get the customer city.

import java.util.Optional;

public class OptionalExample {

record Address(String city, String country) {}
    record Customer(String name, Address address) {}
    record Order(String id, Customer customer) {}

public static void main(String[] args) {

Order order = new Order("ORD-1", new Customer("Alice", new Address("Mumbai", "IN")));
        Order orderNoAddress = new Order("ORD-2", new Customer("Bob", null));
        Order orderNoCustomer = new Order("ORD-3", null);

// Old way: nested null checks - verbose and error-prone
        String city1 = null;
        if (order.customer() != null &&
            order.customer().address() != null) {
            city1 = order.customer().address().city();
        }
        System.out.println("Old way: " + (city1 != null ? city1 : "Unknown"));

// Optional way: safe chaining with map() - clean and readable
        String city2 = Optional.ofNullable(order.customer())
            .map(Customer::address)
            .map(Address::city)
            .orElse("Unknown");
        System.out.println("Optional way: " + city2);

// Empty at first step - chain short-circuits safely
        String city3 = Optional.ofNullable(orderNoCustomer.customer())
            .map(Customer::address)
            .map(Address::city)
            .orElse("Unknown");
        System.out.println("No customer: " + city3);

// Empty in the middle - also safe
        String city4 = Optional.ofNullable(orderNoAddress.customer())
            .map(Customer::address)
            .map(Address::city)
            .orElse("Unknown");
        System.out.println("No address: " + city4);
    }
}

It gives the following output,

Old way: Mumbai
Optional way: Mumbai
No customer: Unknown
No address: Unknown

import java.util.Optional;

public class OptionalFlatMap {

// flatMap: use when the mapping function already returns an Optional
    static Optional<String> findCustomerEmail(String customerId) {
        if ("C-1".equals(customerId)) return Optional.of("alice@example.com");
        return Optional.empty();
    }

static Optional<String> findEmailDomain(String email) {
        int at = email.indexOf("@");
        return at >= 0 ? Optional.of(email.substring(at + 1)) : Optional.empty();
    }

public static void main(String[] args) {
        // flatMap prevents Optional<Optional<String>>
        String domain = Optional.of("C-1")
            .flatMap(OptionalFlatMap::findCustomerEmail)  // returns Optional<String>
            .flatMap(OptionalFlatMap::findEmailDomain)    // returns Optional<String>
            .orElse("domain-not-found");
        System.out.println("Domain: " + domain);

String missing = Optional.of("C-99")
            .flatMap(OptionalFlatMap::findCustomerEmail)
            .flatMap(OptionalFlatMap::findEmailDomain)
            .orElse("domain-not-found");
        System.out.println("Missing: " + missing);
    }
}

It gives the following output,

Domain: example.com
Missing: domain-not-found

Use map() when your lambda returns a plain value. Use flatMap() when your lambda returns an Optional. Never call Optional.get() without first checking isPresent() - it defeats the purpose of Optional entirely. Prefer orElse("default") for constant defaults and orElseGet(() -> computeDefault()) when the default is expensive to compute since orElseGet is lazy.

Send your comments, suggestions or queries regarding this site to [email protected].