Consider the following code snippet that iterates through a list of user information:

// Traditional approach without Optional
if (!CollectionUtils.isEmpty(userInfoList)) {
    for (UserInfo userInfo : userInfoList) {
        // Process userInfo
    }
}

This approach works but can become cumbersome and error-prone when dealing with deeply nested objects. Let's examine another example:

// Potential NullPointerException
String city = orderInfo.getAddress().getCity();

To prevent null pointer exceptions, developers often resort to nested null checks:

// Nested null checks
if (orderInfo != null) {
    Address address = orderInfo.getAddress();
    if (address != null) {
        String city = address.getCity();
    }
}

While effective, this method results in verbose and hard-to-read code. The introduction of Optional in Java 8 offers a cleaner alternative.

Introducing Optional

Using Optional, the same functionality can be achieved with greater elegance:

// Using Optional for null safety
for (UserInfo userInfo : Optional.ofNullable(customers).orElse(new ArrayList<>())) {
    // Process userInfo
}

// Optional chain for deep object access
String city = Optional.ofNullable(orderInfo)
    .map(Order::getAddress)
    .map(Address::getCity)
    .orElseThrow(() -> new IllegalStateException("Order or Address not found"));

Understanding Optional APIs

Optional.ofNullable(), empty(), and of()

These methods create Optional instances:

• ofNullable(T value) returns an empty Optional if the input is null.
• empty() returns an empty Optional instance.
• of(T value) requires a non-null value and throws a NullPointerException if the value is null.

orElseThrow(), orElse(), and orElseGet()

These methods provide fallback options when the Optional value is absent:

• orElseThrow(Supplier<? extends Throwable> supplier) throws an exception when the value is null.
• orElse(T other) returns a default value when the Optional value is null.
• orElseGet(Supplier<? extends T> supplier) computes and returns a default value using a supplier function when the Optional value is null.

map() and flatMap()

These methods transform the value inside an Optional:

• map(Function<T, U> function) applies the function to the value and returns an Optoinal containing the transformed result.
• flatMap(Function<T, Optional<U>> function) similar to map but expects the function to return an Optional directly.

isPresent() and ifPresent()

These methods are used to check the presence of a value:

• isPresent() returns a boolean indicating whether the value is present.
• ifPresent(Consumer<T> consumer) executes the consumer if the value is present.

For example:

// Before Optional
if (userInfo != null) {
    processUserInfo(userInfo);
}

// With Optional
Optional.ofNullable(userInfo).ifPresent(this::processUserInfo);