Optional Class in Java

The Optional class in Java, in java.util, is a container object that may or may not contain a value. It is used as the return type of a method that might have no result, such as "find the student named Navika", instead of returning null. An Optional makes the possibility of "nothing" visible in the method's signature, so callers can't forget to handle it. Optional was added in Java 8. In this lesson, you will learn how to create an Optional and how to read its value safely.

Declaration

public final class Optional<T>

Creating an Optional

Methods of Optional

Example: Returning Optional from a Search

Let's see an example of a method that might not find a student.

import java.util.List;
import java.util.Optional;
 
public class FindStudent {
    record Student(String name, int marks) { }
 
    static final List<Student> STUDENTS = List.of(
        new Student("Navika", 91), new Student("Srihitha", 78));
 
    static Optional<Student> find(String name) {
        return STUDENTS.stream()
            .filter(s -> s.name().equals(name))
            .findFirst();
    }
 
    public static void main(String[] args) {
        Optional<Student> found = find("Navika");
        Optional<Student> missing = find("Advitha");
 
        System.out.println(found.isPresent() + " " + missing.isPresent());
        System.out.println(found.get().marks());
        System.out.println(missing.map(Student::marks).orElse(0));
 
        found.ifPresent(s -> System.out.println("Found " + s.name()));
        missing.ifPresentOrElse(
            s -> System.out.println("Found " + s.name()),
            () -> System.out.println("Advitha is not in the list"));
    }
}

true false
91
0
Found Navika
Advitha is not in the list

Explanation: find returns an Optional<Student>: full when the name exists, empty when it doesn't. get() is safe here only because we know Navika was found. For the missing student, map(Student::marks).orElse(0) gives 0 instead of crashing. ifPresentOrElse handles both cases neatly.

Example: Transforming an Optional

import java.util.Optional;
 
public class Transform {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("  navika  ");
 
        String result = name
            .map(String::strip)
            .filter(n -> n.length() > 3)
            .map(String::toUpperCase)
            .orElse("UNKNOWN");
        System.out.println(result);
 
        Optional<String> blank = Optional.ofNullable(null);
        System.out.println(blank.map(String::toUpperCase).orElse("UNKNOWN"));
 
        try {
            Optional.of(null);
        } catch (NullPointerException e) {
            System.out.println("Optional.of(null) throws");
        }
    }
}

NAVIKA
UNKNOWN
Optional.of(null) throws

Explanation: map and filter work like their stream versions but on at most one value. If the Optional is empty at any step, the rest is skipped and orElse supplies the default. ofNullable(null) gives an empty Optional, while of(null) throws.

Common Mistakes

Calling get() without checking. It throws NoSuchElementException when empty; use orElseThrow() if that's intended, so it reads as deliberate.

Using Optional.of with a value that might be null. Use ofNullable.

Writing if (opt.isPresent()) { x = opt.get(); }. It's just a null check in disguise; use map, orElse or ifPresent.

Interview Corner

Practice

1. Easy: Write a method Optional<Integer> parse(String s) that returns the number, or an empty Optional if the string isn't a valid integer.
2. Harder: Using parse, convert a list of strings into the sum of the valid numbers only, using flatMap(Optional::stream).

Key Takeaways