Elegant Solutions for Java 8 Optional Functional Programming: Chained Handling of ifPresent and if-not-Present

Problem Background and Challenges

In the functional programming paradigm introduced with Java 8, the Optional type was introduced as an elegant solution for handling potentially null values. However, developers frequently encounter a common problem: the need to perform different operations based on whether an Optional contains a value. The traditional implementation typically looks like this:

if (opt.isPresent()) {
    System.out.println("found");
} else {
    System.out.println("Not found");
}

While this code functions correctly, it violates core principles of functional programming—avoiding explicit conditional branches and state mutations. More importantly, it cannot leverage the streaming API and method chaining features introduced in Java 8, resulting in verbose and inelegant code.

Limitations of Existing Solutions

Java 8's Optional class provides the ifPresent() method, but its return type is void, preventing subsequent method chaining. Many developers attempt to write code like this:

opt.ifPresent(x -> System.out.println("found " + x))
   .orElse(System.out.println("NOT FOUND"));

Unfortunately, this approach fails at compile time because the void return type of ifPresent() blocks subsequent method chaining.

Another common attempt uses the map() method combined with orElseGet():

opt.map(o -> {
    System.out.println("while opt is present...");
    o.setProperty(xxx);
    dao.update(o);
    return null;
}).orElseGet(() -> {
    System.out.println("create new obj");
    dao.save(new obj);
    return null;
});

This method has a critical flaw: when the Optional contains a value, both lambda expressions execute, causing unexpected side effects. This occurs because map() transforms the value to null, and orElseGet() still executes when encountering null.

OptionalConsumer Wrapper Class Solution

To address these issues, we can create an OptionalConsumer wrapper class that provides true chained call support. Here's the complete implementation:

public class OptionalConsumer<T> {
    private Optional<T> optional;

    private OptionalConsumer(Optional<T> optional) {
        this.optional = optional;
    }

    public static <T> OptionalConsumer<T> of(Optional<T> optional) {
        return new OptionalConsumer<>(optional);
    }

    public OptionalConsumer<T> ifPresent(Consumer<T> consumer) {
        optional.ifPresent(consumer);
        return this;
    }

    public OptionalConsumer<T> ifNotPresent(Runnable runnable) {
        if (!optional.isPresent()) {
            runnable.run();
        }
        return this;
    }
}

Using this wrapper class, we can write elegant chained code:

Optional<Any> optional = Optional.of(...);
OptionalConsumer.of(optional)
    .ifPresent(value -> System.out.println("isPresent " + value))
    .ifNotPresent(() -> System.out.println("! isPresent"));

Enhanced OptionalConsumer Implementation

To further improve flexibility and performance, we can implement an enhanced version of OptionalConsumer that implements the Consumer<Optional<T>> interface:

public class OptionalConsumer<T> implements Consumer<Optional<T>> {
    private final Consumer<T> presentConsumer;
    private final Runnable absentRunnable;

    public OptionalConsumer(Consumer<T> presentConsumer, Runnable absentRunnable) {
        this.presentConsumer = presentConsumer;
        this.absentRunnable = absentRunnable;
    }

    public static <T> OptionalConsumer<T> of(Consumer<T> presentConsumer, Runnable absentRunnable) {
        return new OptionalConsumer<>(presentConsumer, absentRunnable);
    }

    @Override
    public void accept(Optional<T> optional) {
        if (optional.isPresent()) {
            presentConsumer.accept(optional.get());
        } else {
            absentRunnable.run();
        }
    }
}

This implementation offers three significant advantages:

1. Predefined Functionality: Logic can be defined before the object exists
2. Memory Efficiency: Avoids creating object references for each Optional, reducing memory usage and garbage collection pressure
3. Standard Interface Compatibility: Implements the Consumer interface for easier integration with other components

Usage example:

Consumer<Optional<Integer>> consumer = OptionalConsumer.of(
    System.out::println, 
    () -> System.out.println("Not fit")
);

IntStream.range(0, 100)
    .boxed()
    .map(i -> Optional.of(i))
    .filter(optional -> optional.filter(j -> j % 2 == 0).isPresent())
    .forEach(consumer);

Native Support in Java 9+

For developers using Java 9 and later versions, the Optional class natively provides the ifPresentOrElse() method:

optional.ifPresentOrElse(
    value -> System.out.println("Found: " + value),
    () -> System.out.println("Not found")
);

This method directly addresses the core problem discussed in this article, providing an officially supported solution. However, for projects still using Java 8, the OptionalConsumer wrapper class remains an essential tool.

Performance Considerations and Best Practices

When choosing a solution, consider the performance implications:

• Wrapper Overhead: The OptionalConsumer wrapper introduces minor object creation overhead, but this is negligible in most application scenarios
• Memory Footprint: The enhanced implementation significantly reduces memory usage by reusing Consumer instances
• Readability Balance: While traditional if-else statements have slight performance advantages, functional-style code offers better maintainability and readability

It's recommended to select the appropriate solution based on specific project requirements. For performance-critical paths, consider using traditional conditional statements; for most business logic, functional style provides better code quality and development experience.

Conclusion

The OptionalConsumer wrapper class provides Java 8 developers with an elegant solution that addresses the native Optional's limitations in chained handling of empty cases. By enabling true functional programming style, developers can write cleaner, more maintainable code. As Java evolves, language features continue to improve, but understanding these underlying principles and solutions remains crucial for enhancing programming skills and code quality.