Using Java Optional to Prevent NullPointerException

1. Introduction

Many developers are frustrated by Java's NullPointerException (NPE). Preventing NPE is considered a basic skill for programmers. This article demonstrates how to leverage Java 8's Optional to simplify code and handle NPE efficiently.

2. Understanding and Using Optional

In short, the Optional class is provided by Java to replace manual null != obj checks, reducing the risk of NPE and improving readability.

Typical null check:

// object person
// attributes name, age
Person person = new Person();
if (null == person) {
    return "person is null";
}
return person;

Using Optional:

// object person
// attributes name, age
Person person = new Person();
return Optional.ofNullable(person).orElse("person is null");

Example Person class:

public class Person {
    private String name;
    private Integer age;
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public Person() {}
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
}

2.1 Creating Optional Objects

The internal implementation of Optional shows two private constructors, meaning you cannot instantiate it directly. Instead, use the static factory methods:

public final class Optional
{
    private static final Optional
EMPTY = new Optional<>();
    private final T value;
    private Optional() { this.value = null; }
    private Optional(T value) { this.value = Objects.requireNonNull(value); }
    public static
Optional
empty() { return (Optional
) EMPTY; }
    public static
Optional
of(T value) { return new Optional<>(value); }
    public static
Optional
ofNullable(T value) { return value == null ? empty() : of(value); }
}

Simple usage examples:

// 1. Empty Optional
Optional
optEmpty = Optional.empty();
// 2. Non‑empty Optional
Optional
optOf = Optional.of("optional");
// 3. Nullable Optional
Optional
optOfNullable1 = Optional.ofNullable(null);
Optional
optOfNullable2 = Optional.ofNullable("optional");

2.2 Optional.get()

get() returns the wrapped value or throws NoSuchElementException if the value is null.

public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

2.3 Optional.isPresent()

Returns true if the value is non‑null, otherwise false .

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

2.4 Optional.ifPresent()

Executes the given Consumer only when the value is present.

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

2.5 Optional.filter()

Applies a Predicate to the value; returns the same Optional if the predicate matches, otherwise returns empty() .

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

2.6 Optional.map()

Transforms the contained value using a function and wraps the result in a new Optional .

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

2.7 Optional.flatMap()

Similar to map but the mapping function itself returns an Optional , avoiding nested optionals.

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

2.8 Optional.orElse()

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

public T orElse(T other) {
    return value != null ? value : other;
}

2.9 Optional.orElseGet()

Returns the value if present; otherwise invokes the provided Supplier and returns its result.

public T orElseGet(Supplier
other) {
    return value != null ? value : other.get();
}

2.10 Optional.orElseThrow()

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

public
T orElseThrow(Supplier
exceptionSupplier) throws X {
    if (value != null) return value;
    else throw exceptionSupplier.get();
}

2.11 Comparison of Similar Methods

The article compares orElse , orElseGet , and orElseThrow , as well as map vs. flatMap , highlighting their different signatures and use‑cases.

3. Real‑World Scenarios

Scenario 1

In a service layer, retrieve an object and use ofNullable with orElseThrow to handle missing data.

// Query an object
Member member = memberService.selectByIdNo(request.getCertificateNo());
// Throw if null
Optional.ofNullable(member).orElseThrow(() -> new ServiceException("No related data found"));

Scenario 2

Define repository methods that return Optional directly (e.g., JPA).

public interface LocationRepository extends JpaRepository
{
    Optional
findLocationById(String id);
}

Consume the optional in service code with isPresent , get , and further optional chaining.

public TerminalVO findById(String id) {
    Optional
terminalOptional = terminalRepository.findById(id);
    if (terminalOptional.isPresent()) {
        Terminal terminal = terminalOptional.get();
        TerminalVO vo = BeanCopyUtils.copyBean(terminal, TerminalVO.class);
        Optional
location = locationRepository.findLocationById(terminal.getLocationId());
        if (location.isPresent()) {
            vo.setFullName(location.get().getFullName());
        }
        return vo;
    }
    throw new ServiceException("Terminal does not exist");
}

4. Usage Tips

Optional is powerful but does not replace every if check. For simple field‑null checks, traditional if may be clearer.

Person person = new Person();
person.setName("");
person.setAge(2);
// Traditional check
if (StringUtils.isNotBlank(person.getName())) {
    // name is not empty
}
// Optional check
String name = Optional.ofNullable(person).map(p -> p.getName()).orElse("name is empty");

5. JDK 9 Enhancements

JDK 9 adds three new methods: or() , ifPresentOrElse() , and stream() , providing more expressive ways to handle optional values.

// or() works like orElse but with a Supplier
// ifPresentOrElse(Consumer, Runnable) runs one of two actions based on presence
// stream() converts an Optional to a Stream

These additions further improve the ergonomics of null‑safe programming in Java.

--- End of article ---