Optional Class

Optional<T> is a container object introduced in Java 8 that may or may not hold a non-null value. Its purpose is to make the possible absence of a value explicit in a method's return type, encouraging callers to handle that case deliberately instead of risking an unexpected NullPointerException.

Why it matters

NullPointerException is the most common runtime error in Java, and it usually happens because a method returned null and the caller did not expect it. Returning an Optional states in the method signature that there may be no result, and the caller has to decide what to do in that case. Spring Data repositories, for example, return Optional from findById.

Creating and Checking an Optional

Optional.of(value) wraps a value that must not be null (it throws NullPointerException immediately if it is). Optional.ofNullable(value) accepts a possibly-null value and produces an empty Optional if it is null. Optional.empty() explicitly creates an empty Optional. You can inspect one with isPresent() (true if a value exists) or isEmpty() (true if it does not, added in Java 11).

Consuming a Value Safely

Rather than calling get() directly (which throws if empty), idiomatic Optional usage prefers map() to transform a present value, and orElse(default) or orElseGet(supplier) to supply a fallback when the value is absent. orElseGet is preferred over orElse when computing the default is expensive, because the supplier only runs when actually needed.

• optional.map(String::toUpperCase).orElse("NONE") — transform if present, else fall back.
• optional.ifPresent(v -> System.out.println(v)) — run an action only if a value exists.
• optional.orElseThrow(() -> new NoSuchElementException()) — throw a custom exception if absent.

Where Optional Should — and Should Not — Be Used

Optional is intended as a return type for methods that may legitimately have no result, making that possibility visible in the API. It is explicitly discouraged as the type of class fields, method parameters, or collection elements, because Optional itself can still be null, it adds wrapping overhead, and it is not Serializable — a plain nullable field with clear documentation is preferred in those cases.

Example

import java.util.Optional;

public class OptionalDemo {

    static Optional<String> findUser(int id) {
        if (id == 1) {
            return Optional.of("Asha");
        }
        return Optional.empty();
    }

    public static void main(String[] args) {
        Optional<String> found = findUser(1);
        System.out.println(found.map(String::toUpperCase).orElse("UNKNOWN"));

        Optional<String> missing = findUser(99);
        System.out.println(missing.map(String::toUpperCase).orElse("UNKNOWN"));

        missing.ifPresentOrElse(
                name -> System.out.println("Found: " + name),
                () -> System.out.println("No user found")
        );
    }
}

ASHA
UNKNOWN
No user found

Exercise

Complete findEmail so that it returns an Optional that is empty when the user has no email. The main method prints the email in upper case, or no email when there is none.

Expected output: ASHA@EXAMPLE.COM then no email

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

public class FindEmail {
    static final Map<String, String> EMAILS = Map.of("asha", "asha@example.com");

    static Optional<String> findEmail(String user) {
        // TODO: return an Optional holding the email, or an empty Optional
        return null;
    }

    public static void main(String[] args) {
        System.out.println(findEmail("asha").map(String::toUpperCase).orElse("no email"));
        System.out.println(findEmail("ravi").map(String::toUpperCase).orElse("no email"));
    }
}

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

public class FindEmail {
    static final Map<String, String> EMAILS = Map.of("asha", "asha@example.com");

    static Optional<String> findEmail(String user) {
        return Optional.ofNullable(EMAILS.get(user));
    }

    public static void main(String[] args) {
        System.out.println(findEmail("asha").map(String::toUpperCase).orElse("no email")); // ASHA@EXAMPLE.COM
        System.out.println(findEmail("ravi").map(String::toUpperCase).orElse("no email")); // no email
    }
}

Quick quiz

Interview questions