Understanding and Using Java Optional to Avoid NullPointerException

NullPointerException (NPE) is a common pain point for Java developers, and the Optional class introduced in Java 8 provides a fluent way to handle potentially null values and reduce boilerplate null checks.

Creating Optional objects

// Traditional null check
Person person = new Person();
if (null == person) {
    return "person为null";
}
return person;

// Using Optional
Person person = new Person();
return Optional.ofNullable(person).orElse("person为null");

The Person class used in the examples:

public class Person {
    private String name;
    private Integer age;
    public Person() {}
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    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; }
}

Optional creation 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() {
        @SuppressWarnings("unchecked")
        Optional
t = (Optional
) EMPTY;
        return t;
    }
    public static
Optional
of(T value) { return new Optional<>(value); }
    public static
Optional
ofNullable(T value) { return value == null ? empty() : of(value); }
}

Typical usage:

Optional
optEmpty = Optional.empty();
Optional
optOf = Optional.of("optional");
Optional
optOfNullable1 = Optional.ofNullable(null);
Optional
optOfNullable2 = Optional.ofNullable("optional");

Key instance methods

get() – returns the wrapped value or throws NoSuchElementException when empty.

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

Person person = new Person();
person.setAge(2);
Optional.ofNullable(person).get();

isPresent() – checks whether a value is present.

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

Person person = new Person();
person.setAge(2);
if (Optional.ofNullable(person).isPresent()) {
    System.out.println("不为空");
} else {
    System.out.println("为空");
}

ifPresent(Consumer) – executes the consumer only when the value is non‑null.

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

Person person = new Person();
person.setAge(2);
Optional.ofNullable(person).ifPresent(p -> System.out.println("年龄" + p.getAge()));

filter(Predicate) – returns the same Optional if the predicate matches, otherwise empty() .

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

Person person = new Person();
person.setAge(2);
Optional.ofNullable(person).filter(p -> p.getAge() > 50);

map(Function) – transforms the contained value and wraps the result.

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

Person person = new Person();
person.setAge(2);
String optName = Optional.ofNullable(person)
    .map(p -> p.getName())
    .orElse("name为空");

flatMap(Function) – similar to map but the mapping function itself returns an Optional .

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

Person person = new Person();
person.setAge(2);
Optional
optName = Optional.ofNullable(person)
    .map(p -> Optional.ofNullable(p.getName()).orElse("name为空"));

orElse(T) – returns the value if present, otherwise the supplied default.

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

orElseGet(Supplier) – lazily provides a default value.

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

Optional
> sup = Optional.ofNullable(Person::new);
Optional.ofNullable(person).orElseGet(sup.get());

orElseThrow(Supplier) – throws a supplied exception when the Optional is empty.

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

Member member = memberService.selectByPhone(request.getPhone());
Optional.ofNullable(member).orElseThrow(() -> new ServiceException("没有查询的相关数据"));

Practical scenarios

// Service layer validation
Member member = memberService.selectByIdNo(request.getCertificateNo());
Optional.ofNullable(member).orElseThrow(() -> new ServiceException("没有查询的相关数据"));

// DAO returns Optional directly (JPA example)
public interface LocationRepository extends JpaRepository
{
    Optional
findLocationById(String id);
}

// Consuming the DAO Optional
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("该终端不存在");

JDK 9 enhancements

Java 9 adds three convenient methods to Optional :

or() – similar to orElse but takes another Optional.

ifPresentOrElse(Consumer, Runnable) – executes one of two actions based on presence.

stream() – converts the Optional into a Stream for further functional processing.

While Optional greatly simplifies null‑handling, it is not a universal replacement for all conditional logic; simple checks on individual fields may still be clearer with traditional if statements.

Overall, mastering Optional helps write more expressive, null‑safe Java code and aligns with modern functional‑style programming practices.