Optional & Modern Java

Introducing Optional

15 min Lesson 2 of 13

Introducing Optional

In the previous lesson we saw how null leads to NullPointerException, unclear contracts, and defensive code scattered everywhere. Java 8 introduced java.util.Optional<T> as a typed container that explicitly represents the possibility of absence. This lesson covers the three factory methods you use to create an Optional and the basic ways to ask whether it holds a value.

What Optional Is — and Is Not

Optional<T> is a value-type wrapper. It has exactly two states:

Present — it wraps a non-null value of type T.
Empty — it holds no value at all (analogous to null, but explicit).

Optional is a return-type tool, not a field type. Its purpose is to make a method's signature say "this might not return anything" without the caller having to read Javadoc or guess. It is not a general-purpose replacement for every nullable reference in the codebase — using it as a field type or a method parameter adds overhead with little benefit.

Three Factory Methods

Optional.of — when you are certain a value exists

Optional.of(value) wraps a value that you know is non-null. If you pass null it throws NullPointerException immediately, which is intentional — it fails fast at the construction site rather than silently propagating.

import java.util.Optional;

String name = "Alice";
Optional<String> opt = Optional.of(name);   // safe: name is definitely non-null

// Passing null explodes right here — good, fail fast
// Optional<String> bad = Optional.of(null);  // throws NullPointerException

Use Optional.of when the value comes from a source you control and can guarantee is non-null — for example, a constant, a freshly constructed object, or a value you just validated.

Optional.ofNullable — when the value may or may not be null

Optional.ofNullable(value) is the most common factory. It inspects the value: if it is non-null it returns a present Optional; if it is null it returns an empty Optional. This is the bridge between legacy null-returning APIs and the Optional world.

import java.util.Optional;
import java.util.Map;

Map<String, String> config = Map.of("host", "localhost");

// getOrDefault does not exist on this map for "port", so get() returns null
Optional<String> maybePort = Optional.ofNullable(config.get("port"));

System.out.println(maybePort);           // Optional.empty
System.out.println(maybePort.isPresent()); // false

Optional<String> maybeHost = Optional.ofNullable(config.get("host"));
System.out.println(maybeHost);           // Optional[localhost]
System.out.println(maybeHost.isPresent()); // true

Optional.empty — an explicit empty Optional

Optional.empty() creates an empty container with no value. You use it in methods that return Optional<T> when there is nothing to return — it is the typed, intentional replacement for return null.

import java.util.Optional;
import java.util.List;

public Optional<String> findFirstLongWord(List<String> words, int minLength) {
    for (String word : words) {
        if (word.length() >= minLength) {
            return Optional.of(word);        // found one — wrap it
        }
    }
    return Optional.empty();                 // nothing matched — explicit
}

Returning Optional.empty() is far more honest than returning null: the compiler enforces that callers handle a Optional<String> return type, and no annotation or comment is needed to communicate absence.

Checking Presence

Once you hold an Optional you can ask whether it contains a value using three related methods:

isPresent() — returns true if a value is present.
isEmpty() — returns true if the container is empty (added in Java 11; the readable inverse of isPresent()).
get() — returns the wrapped value, but throws NoSuchElementException if empty.

import java.util.Optional;

Optional<Integer> score = Optional.of(42);

if (score.isPresent()) {
    System.out.println("Score: " + score.get());   // Score: 42
}

Optional<Integer> noScore = Optional.empty();

if (noScore.isEmpty()) {
    System.out.println("No score recorded.");      // No score recorded.
}

// Dangerous — always guard get() with isPresent() or prefer safer methods
// noScore.get();   // throws NoSuchElementException

Avoid bare get() in production code. Calling get() without a prior isPresent() check is exactly as dangerous as dereferencing a potentially-null reference — you just traded NullPointerException for NoSuchElementException. In the next lessons you will learn safer extraction methods (orElse, orElseGet, map, ifPresent) that express intent more cleanly and cannot throw.

Equality and toString

Optional overrides equals and hashCode by delegating to the wrapped value, so two present Optionals with equal values are equal, and two empty Optionals are always equal to each other.

Optional<String> a = Optional.of("hello");
Optional<String> b = Optional.of("hello");
Optional<String> c = Optional.empty();
Optional<String> d = Optional.empty();

System.out.println(a.equals(b));   // true
System.out.println(c.equals(d));   // true
System.out.println(a.equals(c));   // false

// toString is readable for debugging
System.out.println(a);             // Optional[hello]
System.out.println(c);             // Optional.empty

Choosing the Right Factory

A simple decision tree:

You control the value and it can never be null → Optional.of(value)
The value comes from a legacy API or user input that might be null → Optional.ofNullable(value)
You are writing a method and have no result to return → Optional.empty()

Prefer ofNullable when in doubt. If you are not 100% sure a value is non-null, use ofNullable. The extra null-check costs nothing measurable, and the fail-fast of of is only useful when you actually want to crash loudly on a contract violation — for example, in constructor validation.

Summary

Optional.of wraps a guaranteed-non-null value and fails fast on null. Optional.ofNullable wraps anything, silently converting null to empty. Optional.empty() represents an explicit no-value return. To inspect the state use isPresent() or isEmpty() (Java 11+), and treat bare get() as a last resort that requires a guard. In the next lesson you will see the richer extraction and transformation API — orElse, orElseGet, orElseThrow — that makes Optional genuinely useful rather than just a renamed null check.