Mastering Java 8 Optional: Avoid NullPointerException with Elegant Code

NullPointerException (NPE) is a common issue in Java development. The traditional approach of nested null‑checks, such as

if (user != null) { Address address = user.getAddress(); if (address != null) { String province = address.getProvince(); } }

, leads to ugly and hard‑to‑maintain code.

Java 8 introduces the Optional class to handle potentially null values more gracefully. This article reviews the main API methods and shows how to replace manual null checks with fluent, functional style.

API Overview

The key factory methods are: Optional(T value) – private constructor, not directly callable. empty() – returns a singleton empty Optional. of(T value) – creates an Optional and throws NPE if value is null. ofNullable(T value) – returns empty() when value is null, otherwise behaves like of.

Source snippets:

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

public static <T> Optional<T> ofNullable(T value) { return value == null ? empty() : of(value); }

Handling Null Values

When a value may be absent, orElse and orElseGet provide defaults:

@Test
public void test() {
    User user = null;
    user = Optional.ofNullable(user).orElse(createUser());
    user = Optional.ofNullable(user).orElseGet(() -> createUser());
}

public User createUser(){
    User user = new User();
    user.setName("zhangsan");
    return user;
}

orElse

always evaluates the argument, while orElseGet evaluates lazily only when needed. orElseThrow throws a supplied exception when the value is absent:

User user = null;
Optional.ofNullable(user).orElseThrow(() -> new Exception("User not found"));

Transforming Values

map

and flatMap convert the contained value. map expects a Function<? super T, ? extends U> and wraps the result in an Optional. flatMap expects a function returning an Optional<U>, avoiding nested optionals.

String city = Optional.ofNullable(user).map(u -> u.getName()).get();
String city = Optional.ofNullable(user).flatMap(u -> u.getName()).get();

Presence Checks

isPresent()

returns true if a value exists; ifPresent(Consumer) executes an action only when the value is present:

Optional.ofNullable(user).ifPresent(u -> { /* do something */ });

Filtering

filter(Predicate)

keeps the Optional when the predicate matches, otherwise returns empty():

Optional<User> user1 = Optional.ofNullable(user).filter(u -> u.getName().length() < 6);

Practical Refactorings

Example 1 – Getting a city

public String getCity(User user) throws Exception {
    return Optional.ofNullable(user)
                   .map(u -> u.getAddress())
                   .map(a -> a.getCity())
                   .orElseThrow(() -> new Exception("Invalid value"));
}

Example 2 – Conditional execution

Optional.ofNullable(user).ifPresent(u -> {
    doSomething(u);
});

Example 3 – Conditional creation

public User getUser(User user) {
    return Optional.ofNullable(user)
                   .filter(u -> "zhangsan".equals(u.getName()))
                   .orElseGet(() -> {
                       User u1 = new User();
                       u1.setName("zhangsan");
                       return u1;
                   });
}

These chain‑style usages make the code more concise, though readability should be considered in real projects.

Source: CSDN (original link: blog.csdn.net/zjhred/article/details/84976734)