Master Core Java Programming From Scratch

What is Optional?

Optional<T> is a container object that may contain a non-null value or may be empty.

It is commonly used as a return type when the absence of a result is a valid possibility.

                                            Value Available
                                                  ↓
                                            Optional<T>
                                                  ↓
                                                Use Value
                                                  ↓
                                                No Value
                                                  ↓
                                            Optional.empty()
                                                  ↓
                                            Handle Absence

Creating Optional

Java provides several factory methods for creating Optional instances.

Optional<String> value =
    Optional.of("CIIT");

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

Optional<String> nullable =
    Optional.ofNullable(
        getName()
    );

Optional.of()

Optional.of() creates an Optional containing a non-null value.

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

System.out.println(name);

Output:

Optional[Sam]

Optional.ofNullable()

Optional.ofNullable() creates an Optional that contains the value when it is non-null, otherwise it creates an empty Optional.

String name = null;

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

System.out.println(result);

Output:

Optional.empty

Optional.empty()

Optional.empty() represents an Optional with no value.

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

System.out.println(
    result.isEmpty()
);

Output:

true

isPresent()

isPresent() checks whether a value exists.

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

if (name.isPresent()) {

    System.out.println(
        "Value is available"
    );

}

Output:

Value is available

isEmpty()

isEmpty() checks whether an Optional contains no value.

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

if (name.isEmpty()) {

    System.out.println(
        "No value available"
    );

}

Output:

No value available

get()

get() returns the contained value.

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

String value =
    name.get();

System.out.println(value);

Output:

Sam

orElse()

orElse() returns the contained value or a fallback value when the Optional is empty.

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

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

System.out.println(result);

Output:

Unknown

orElseGet()

orElseGet() accepts a Supplier and computes the fallback value when it is actually needed.

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

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

System.out.println(result);

Output:

Generated Name

orElseThrow()

orElseThrow() returns the value when present and throws an exception when the Optional is empty.

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

String result =
    name.orElseThrow();

System.out.println(result);

Output:

Amit

orElseThrow() with Custom Exception

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

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

ifPresent()

ifPresent() executes a Consumer when a value is present.

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

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

Output:

Priya

ifPresentOrElse()

ifPresentOrElse() allows separate actions for present and empty cases.

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

name.ifPresentOrElse(

    value ->
        System.out.println(
            "Name: " + value
        ),

    () ->
        System.out.println(
            "Name not found"
        )
);

filter()

filter() keeps the Optional value only when it satisfies the supplied predicate.

Optional<Integer> age =
    Optional.of(25);

Optional<Integer> adultAge =
    age.filter(
        value -> value >= 18
    );

adultAge.ifPresent(
    System.out::println
);

Output:

25

map()

map() transforms the value inside the Optional when it is present.

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

Optional<String> upper =
    name.map(
        String::toUpperCase
    );

System.out.println(
    upper.orElse("UNKNOWN")
);

Output:

JAVA

flatMap()

flatMap() is useful when the mapping function itself returns an Optional and you want to avoid nested Optional values.

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

Optional<String> result =
    name.flatMap(
        value ->
            Optional.of(
                value.toUpperCase()
            )
    );

System.out.println(
    result.orElse("Unknown")
);

Output:

AMIT

map() vs flatMap()

or()

The or() method can provide another Optional when the current Optional is empty.

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

Optional<String> backup =
    Optional.of("Backup Value");

Optional<String> result =
    primary.or(
        () -> backup
    );

System.out.println(
    result.orElse("None")
);

Output:

Backup Value

Optional and Stream API

Optional integrates naturally with stream operations such as findFirst() and findAny().

List<String> names =
    List.of(
        "Amit",
        "Neha",
        "Rahul"
    );

Optional<String> result =
    names.stream()
        .filter(
            name ->
                name.startsWith("N")
        )
        .findFirst();

result.ifPresent(
    System.out::println
);

Output:

Neha

Optional as a Method Return Type

One common use of Optional is representing a method result that may not exist.

Optional<User> findUserById(
    int id
) {

    // Search user

    return Optional.empty();
}

The caller can explicitly handle the possibility that no user was found.

Real-World Example

Optional<User> user =
    findUserById(101);

String name =
    user.map(
        User::getName
    )
    .orElse(
        "User Not Found"
    );

System.out.println(name);

OptionalInt, OptionalLong and OptionalDouble

Java provides primitive-specialized Optional classes for numeric values.

OptionalInt age =
    OptionalInt.of(25);

if (age.isPresent()) {

    System.out.println(
        age.getAsInt()
    );

}

Output:

25

Optional Best Practices

• Use Optional mainly as a return type where absence is meaningful.
• Avoid blindly calling get().
• Prefer orElse(), orElseGet(), or orElseThrow() when appropriate.
• Use map() and flatMap() for transformations.
• Use ifPresent() when an action should happen only when a value exists.
• Do not use Optional merely to wrap every field in a domain object.

Common Mistakes

orElse() vs orElseGet()

The fallback expression passed to orElse() is evaluated even when the Optional contains a value. With orElseGet(), the Supplier is invoked only when the Optional is empty.

String result =
    optionalValue.orElse(
        createDefaultValue()
    );

String result =
    optionalValue.orElseGet(
        () ->
            createDefaultValue()
    );

Interview Questions