Master Java Optional: Clean Null Handling with Real-World Examples

Background Introduction

NullPointerException

, known in Chinese as 空指针异常 (NPE), is one of the most common runtime errors in software systems.

Google Guava introduced Optional to reduce explicit null checks, encouraging cleaner and more readable code. Since then, Optional has become part of the Java 8+ standard library.

Before showing Optional, consider why Google discourages excessive explicit null checks.

Typical three‑level null‑checking code:

// Check if country is null
if (country != null) {
    // Check if city's parent is null
    if (country.getCity() != null) {
        // Check if province is null
        if (country.getCity().getProvince() != null) {
            // Retrieve province name
            return country.getCity().getProvince().getName();
        }
    }
}

When business logic grows, such code becomes bulky and hard to read.

Using Optional the same logic can be written as:

// Get the top‑level province name of the current region
String result = Optional.ofNullable(country)
        .map(Country::getCity)
        .map(City::getProvince)
        .map(Province::getName)
        .orElse("error");

Adopting Optional greatly improves readability and cleanliness.

Case Practice

In JDK 8, Optional provides 12 core methods. Below are their usages.

empty()

Returns an empty Optional instance; usually combined with other methods.

Optional optional = Optional.empty();
System.out.println(optional);
// Output: Optional.empty

of()

Creates an Optional containing a non‑null value; throws NullPointerException if the argument is null.

// Non‑null value
Optional optional = Optional.of("hello world");
System.out.println(optional); // Output: Optional[hello world]

// Null value – throws NPE
Optional optional = Optional.of(null);

ofNullable()

Returns an Optional containing the value if non‑null, otherwise returns Optional.empty().

// Non‑null
Optional optional = Optional.ofNullable("hello world");
System.out.println(optional); // Output: Optional[hello world]

// Null
Optional optional = Optional.ofNullable(null);
System.out.println(optional); // Output: Optional.empty

isPresent()

Checks whether the Optional contains a value.

boolean rs1 = Optional.ofNullable("hello").isPresent(); // true
boolean rs2 = Optional.ofNullable(null).isPresent();   // false
System.out.println(rs1);
System.out.println(rs2);

get()

Returns the contained value if present; otherwise throws NoSuchElementException.

// Non‑null
Object rs = Optional.ofNullable("hello world").get();
System.out.println(rs); // hello world

// Null – throws exception
Object rs = Optional.ofNullable(null).get();

ifPresent()

Executes a consumer when a value is present.

Optional.ofNullable("hello world")
        .ifPresent(x -> System.out.println(x)); // prints hello world

filter()

Filters the value with a Predicate; returns the same Optional if the predicate matches, otherwise returns empty.

Optional.ofNullable("hello world")
        .filter(x -> x.contains("hello"))
        .ifPresent(System.out::println); // prints hello world

map()

Applies a function to the contained value and wraps the result in a new Optional.

Optional.ofNullable("hello+world")
        .map(t -> {
            if (t.contains("+")) {
                return t.replace("+", " ");
            }
            return t;
        })
        .ifPresent(System.out::println); // prints hello world

flatMap()

Similar to map but the mapping function must itself return an Optional.

Optional.ofNullable("hello+world")
        .flatMap(t -> {
            if (t.contains("+")) {
                t = t.replace("+", " ");
            }
            return Optional.of(t);
        })
        .ifPresent(System.out::println); // prints hello world

orElse()

Returns the value if present; otherwise returns a default value.

Object rs = Optional.ofNullable(null).orElse("null");
System.out.println(rs); // prints null

orElseGet()

Returns the value if present; otherwise invokes a Supplier to provide a fallback.

Object result = Optional.ofNullable(null)
        .orElseGet(() -> "error");
System.out.println(result); // prints error

orElseThrow()

Returns the value if present; otherwise throws an exception supplied by a Supplier.

Optional.ofNullable(null)
        .orElseThrow(() -> new RuntimeException("Parameter is null"));

Conclusion

The most frequently used Optional methods are ofNullable, map, and orElse. orElse, orElseGet, and orElseThrow differ in how they handle absent values: returning a default value, invoking a supplier, or throwing an exception respectively. Choose the appropriate method based on the specific scenario to write cleaner, more maintainable Java code.