Optional in Java

Sometimes a method needs to return a value, but there is a possibility that no value exists.

For example, suppose we search for a student by name. What happens if the student doesn't exist?

Traditionally, Java might return null:

Student student = findStudent("John");

If John doesn't exist, student might be null.

Then we have to remember to check:

if (student != null) {
    System.out.println(student.name);
}

If we forget the check and try to use student, we could get a NullPointerException.

Java provides Optional to handle this situation more safely.

Optional is a container that can either contain a value or be empty.

Think of it like a box:

Optional
   ↓
 ┌─────────┐
 │  Value  │  ← if a value exists
 └─────────┘

or

 ┌─────────┐
 │  Empty  │  ← if no value exists
 └─────────┘

Creating an Optional

Optional is part of the java.util package.

import java.util.Optional;

We can create an Optional containing a value using of():

Optional<String> name = Optional.of("John");

Here, the Optional contains "John".

We can retrieve the value using get():

System.out.println(name.get());

Output:

John

However, using get() without checking whether a value exists can cause a problem. So there are safer ways to work with Optional.

Optional.empty()

Sometimes we want to represent the absence of a value.

We can use:

Optional<String> name = Optional.empty();

This Optional contains nothing.

We can check whether it contains a value:

System.out.println(name.isPresent());

Output:

false

If we have:

Optional<String> name = Optional.of("John");

System.out.println(name.isPresent());

the result is:

true

Optional.ofNullable()

There is an important difference between of() and ofNullable().

If we know the value will never be null, we can use:

Optional<String> name = Optional.of("John");

But if the value might be null, we can use:

String name = null;

Optional<String> result = Optional.ofNullable(name);

ofNullable() creates an empty Optional if the value is null.

This makes it very useful when dealing with values that may or may not exist.

Using isPresent()

We can check whether an Optional contains a value:

Optional<String> name = Optional.of("John");

if (name.isPresent()) {
    System.out.println(name.get());
}

Output:

John

If the Optional is empty, the code inside the if won't run.

ifPresent()

Java also provides a cleaner way to perform an action only when a value exists.

Optional<String> name = Optional.of("John");

name.ifPresent(value -> System.out.println(value));

Output:

John

Here, the lambda runs only if the Optional contains a value.

This is especially useful when working with the Stream API.

Providing a Default Value

Sometimes, instead of doing nothing when a value is missing, we want to use a default value.

For this, we can use orElse().

Optional<String> name = Optional.empty();

String result = name.orElse("Unknown");

System.out.println(result);

Output:

Unknown

If the Optional contains a value:

Optional<String> name = Optional.of("John");

String result = name.orElse("Unknown");

System.out.println(result);

Output:

John

So:

Value exists → use the value
No value     → use "Unknown"

orElseGet()

orElseGet() is similar to orElse(), but it takes a Supplier that creates the default value when needed.

For example:

Optional<String> name = Optional.empty();

String result = name.orElseGet(() -> "Unknown");

System.out.println(result);

Output:

Unknown

For simple default values, orElse() is usually enough. orElseGet() becomes useful when creating the default value requires some work.

orElseThrow()

Sometimes a missing value should be treated as an error.

We can use orElseThrow():

Optional<String> name = Optional.empty();

String result = name.orElseThrow();

If the Optional is empty, Java throws an exception.

We can also provide our own exception:

String result = name.orElseThrow(
    () -> new IllegalArgumentException("Name not found")
);

This is useful when the absence of a value should not be ignored.

Optional with Methods

Optional is commonly used as a return type for methods that might not find a value.

For example:

static Optional<String> findStudent(String name) {

    if (name.equals("John")) {
        return Optional.of("John");
    }

    return Optional.empty();
}

Now we can call:

Optional<String> student = findStudent("John");

student.ifPresent(
    value -> System.out.println("Student found: " + value)
);

Output:

Student found: John

If we search for someone who doesn't exist:

Optional<String> student = findStudent("Alex");

student.ifPresent(
    value -> System.out.println("Student found: " + value)
);

Nothing is printed because the Optional is empty.

Optional with Stream API

You may have already seen Optional while learning the Stream API.

For example:

Optional<Integer> result = numbers.stream()
        .filter(number -> number > 50)
        .findFirst();

Why does findFirst() return an Optional?

Because there might not be any number greater than 50.

Instead of returning null, Java returns:

Optional containing a value

or:

Optional.empty()

We can safely handle it:

result.ifPresent(number -> System.out.println(number));

Optional Does Not Mean "Never Use null"

Optional is mainly useful when we want to clearly represent that a value may or may not exist, especially as a method return value.

It doesn't mean every variable in your program should be wrapped in Optional.

For example, this is usually unnecessary:

Optional<String> name = Optional.of("John");

if the value is guaranteed to exist and there's no meaningful absence to represent.

The real benefit comes when a value might genuinely be missing.

A Complete Example

Let's create a simple method that searches for a student:

import java.util.Optional;

class Main {

    static Optional<String> findStudent(String name) {

        if (name.equals("John")) {
            return Optional.of("John");
        }

        return Optional.empty();
    }

    public static void main(String[] args) {

        Optional<String> student = findStudent("John");

        String result = student.orElse("Student not found.");

        System.out.println(result);
    }
}

Output:

John

If we search for "Alex" instead:

Optional<String> student = findStudent("Alex");

String result = student.orElse("Student not found.");

Output:

Student not found.

The main idea is:

Optional is a container that represents a value that may or may not be present.

Instead of simply returning null, a method can return an Optional and let the caller safely decide what to do when the value exists or when it doesn't.