Understanding Java 8 Optional: API Overview, Core Methods, and Practical Usage

At the beginning the article describes the common NullPointerException (NPE) issue in Java and presents a typical null‑checking code snippet:

user.getAddress().getProvince();

When user is null this throws an NPE, so a verbose guard is often written:

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

Java 8 provides the Optional class to make such code more elegant. The article first introduces the API, emphasizing that the constructor Optional(T value) is private and that the public factory methods are of , empty , and ofNullable .

The source of of is shown:

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

and the source of empty :

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

ofNullable combines the two:

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

The article explains that of throws an NPE when the argument is null , while ofNullable safely returns EMPTY .

Next, the three methods dealing with default values are described:

orElse(T other) – returns the contained value or the supplied default, but always evaluates the default expression.

orElseGet(Supplier supplier) – lazily supplies a default value only when needed.

orElseThrow(Supplier exceptionSupplier) – throws the provided exception when the value is absent.

Example code demonstrates the difference between orElse and orElseGet :

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

The map and flatMap methods are then presented as ways to transform the contained value. Their source is shown:

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

Usage examples illustrate extracting a name from a User object with map and with flatMap when the getter itself returns an Optional .

The methods isPresent() and ifPresent(Consumer ) are described next. Their source is shown, and a warning is given not to misuse them by writing if (Optional.isPresent()) which would still be verbose.

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

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

The filter(Predicate ) method is introduced, with source code and an example that keeps the Optional only when the user's name length is less than six:

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

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

Finally, several practical examples show how to replace nested null checks with concise Optional chains, such as retrieving a city from a user, or conditionally creating a default user object.

Overall, the article demonstrates that while Optional can make code more fluent, developers should balance elegance with readability in real projects.