Using Java 8 Optional API to Eliminate NullPointerException

The article begins by describing the common NullPointerException (NPE) problem in Java and presents a UML diagram of two classes to illustrate the issue when accessing nested properties like user.getAddress().getProvince() without null checks.

It then introduces Java 8's Optional class as a solution, explaining its purpose and showing how to avoid the ugly nested if statements.

API Overview

The four core factory methods are discussed:

Optional(T value) – private constructor that stores a value and checks for null.

of(T value) – creates an Optional and throws NPE if the argument is null.

ofNullable(T value) – returns EMPTY when the argument is null, otherwise creates an Optional .

empty() – returns a singleton empty Optional .

Source snippets:

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

public static final Optional
EMPTY = new Optional<>();
private Optional() { this.value = null; }
public static
Optional
empty() {
    @SuppressWarnings("unchecked")
    Optional
t = (Optional
) EMPTY;
    return t;
}

The article compares of and ofNullable , noting that of throws an exception for null values while ofNullable safely returns EMPTY .

Value Retrieval Methods

Three methods for handling absent values are covered:

orElse(T other) – returns the contained value or a default.

orElseGet(Supplier<? extends T> supplier) – lazily provides a default only when needed.

orElseThrow(Supplier<? extends X> exceptionSupplier) – throws a custom exception if the value is absent.

@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;
}

Transformation Methods

The map and flatMap functions are explained, showing how they transform the contained value or flatten nested Optional results.

public final
Optional
map(Function
mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()) return empty();
    else return Optional.ofNullable(mapper.apply(value));
}

public final
Optional
flatMap(Function
> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent()) return empty();
    else return Objects.requireNonNull(mapper.apply(value));
}

Examples demonstrate extracting a user's name with map and retrieving an Optional name with flatMap :

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

Presence Checks

The isPresent() method checks for a non‑null value, while ifPresent(Consumer<? super T> consumer) executes an action only when the value exists.

public boolean isPresent() { return value != null; }
public void ifPresent(Consumer
consumer) {
    if (value != null) consumer.accept(value);
}

Usage example:

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

Filtering

The filter(Predicate<? super T> predicate) method retains the Optional only if the predicate is true, otherwise returns EMPTY .

public final Optional
filter(Predicate
predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent()) return this;
    else return predicate.test(value) ? this : empty();
}

Example:

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

Practical Examples

Three real‑world scenarios replace traditional null checks with fluent Optional chains, showing how to retrieve a city, conditionally execute code, and create or modify a user object more elegantly.

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

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

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;
        });
}

The article concludes that while Optional makes code more concise, developers should balance readability and use it judiciously in projects.