Using Java 8 Optional to Avoid NullPointerException: API Overview and Practical Examples

In Java development, encountering NullPointerException (NPE) is common when accessing properties of a null object. The article starts with a traditional null‑check example that can lead to NPE:

user.getAddress().getProvince();

When user is null, this call throws an exception. A verbose defensive approach checks each level:

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

To make the code cleaner, Java 8 provides the Optional class, which the article introduces in detail.

API Overview

The Optional class has a private constructor Optional(T value) that stores a value if it is non‑null. The public factory methods include:

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

The of method throws NullPointerException when value is null.

public static
Optional
empty() {
    @SuppressWarnings("unchecked")
    Optional
t = (Optional
) EMPTY;
    return t;
}

The empty method returns a singleton empty Optional .

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

The ofNullable method safely creates an Optional without throwing an exception when the argument is null.

Key Instance Methods

orElse(T other) and orElseGet(Supplier<? extends T> supplier) provide fallback values when the contained value is null. The difference is that orElse evaluates the argument eagerly, while orElseGet evaluates the supplier lazily:

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

orElseThrow(Supplier<? extends Throwable> exceptionSupplier) throws the supplied exception when the value is absent:

User user = null;
Optional.ofNullable(user).orElseThrow(() -> new Exception("用户不存在"));

map(Function<? super T, ? extends U> mapper) transforms the contained value, while flatMap(Function<? super T, Optional<U>> mapper) returns an Optional directly. Example implementations from the source:

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

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

isPresent() checks if a value exists, and ifPresent(Consumer<? super T> consumer) executes an action when the value is present:

public boolean isPresent() {
    return value != null;
}

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

filter(Predicate<? super T> predicate) retains the Optional only if the predicate matches; otherwise it returns empty() :

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

Practical usage examples demonstrate replacing nested null checks with concise Optional chains.

Example 1 – Getting City

public String getCity(User user) throws Exception {
    if(user != null) {
        if(user.getAddress() != null) {
            Address address = user.getAddress();
            if(address.getCity() != null) {
                return address.getCity();
            }
        }
    }
    throw new Exception("取值错误");
}

Java 8 version:

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

Example 2 – Conditional Execution

if(user != null) {
    dosomething(user);
}

Java 8 version:

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

Example 3 – Getting or Creating a User

public User getUser(User user) throws Exception {
    if(user != null) {
        String name = user.getName();
        if("zhangsan".equals(name)) {
            return user;
        }
    } else {
        user = new User();
        user.setName("zhangsan");
        return user;
    }
}

Java 8 version:

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

The article concludes that while Optional makes code more fluent, developers should balance elegance with readability in real projects.