7.4 Working with java.util.Optional

Working with java.util.Optional

The java.util.Optional<T> class, introduced in Java 8 and enriched in Java 9, 10, and 11, is a value-based container object that may or may not contain a non-null value of type T. It was designed primarily as a method return type to provide a clear, type-level contract indicating that a return value might be absent, thereby preventing NullPointerException (NPE) bugs. For the 1Z0-830 exam, you must master Optional creation methods, unwrap mechanisms (orElse vs. orElseGet), transformation combinators (map, flatMap, filter, or, stream), primitive optionals, and recognized architectural best practices.

---

1. Creating Optional Instances

Java provides three static factory methods to create Optional objects:

+-----------------------------------------------------------------------------------------+
|                            OPTIONAL CREATION FACTORIES                                  |
|                                                                                         |
|  1. Optional.empty()            : Returns empty container (no value)                    |
|  2. Optional.of(val)            : Returns Optional with val; THROWS NPE if val == null |
|  3. Optional.ofNullable(val)    : Returns Optional with val IF non-null;                |
|                                   Returns Optional.empty() IF val == null               |
+-----------------------------------------------------------------------------------------+

// 1. Explicit Empty Optional
Optional<String> emptyOpt = Optional.empty();
System.out.println(emptyOpt.isEmpty()); // true (Java 11+)

// 2. Optional.of(value) - Strict non-null enforcement
String validText = "Java 21";
Optional<String> opt1 = Optional.of(validText); // Contains "Java 21"
// Optional<String> optNull = Optional.of(null); // THROWS NullPointerException IMMEDIATELY!

// 3. Optional.ofNullable(value) - Null-safe factory
String nullableText = null;
Optional<String> opt2 = Optional.ofNullable(nullableText); // Returns Optional.empty() safely
Optional<String> opt3 = Optional.ofNullable("Ready");      // Contains "Ready"

---

2. Checking Presence and Conditional Consumption

Instead of checking if (val != null), Optional provides query methods and functional consumers:

• boolean isPresent(): Returns true if a value is present, otherwise false.
• boolean isEmpty(): (Java 11+) Returns true if empty, otherwise false (equivalent to !isPresent()).
• void ifPresent(Consumer<? super T> action): If a value is present, invokes action.accept(val); otherwise does nothing.
• void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction): (Java 9+) If present, performs action; otherwise executes the emptyAction runnable.

Optional<String> userOpt = Optional.ofNullable(getUserName());

// Classic query check
if (userOpt.isPresent()) {
    System.out.println("User: " + userOpt.get());
}

// Functional consumption
userOpt.ifPresent(name -> System.out.println("Hello, " + name));

// Java 9+ Branching Consumption
userOpt.ifPresentOrElse(
    name -> System.out.println("Welcome back, " + name),
    () -> System.out.println("Guest access")
);

---

3. Unwrapping Values and Fallback Strategies

Extracting values from an Optional can be accomplished through several strategies, each with distinct evaluation semantics:

+-----------------------------------------------------------------------------------------+
|                           UNWRAPPING & FALLBACK COMPARISON                              |
|                                                                                         |
|  Method                     Evaluation Mode      Behavior when Empty                    |
|  ────────────────────────   ──────────────────   ─────────────────────────────────────  |
|  opt.get()                  Direct               Throws NoSuchElementException          |
|  opt.orElse(defaultVal)     EAGER                Returns defaultVal (always evaluated)  |
|  opt.orElseGet(supplier)    LAZY                 Executes supplier.get() only if empty  |
|  opt.orElseThrow()          Lazy / Direct        Throws NoSuchElementException          |
|  opt.orElseThrow(supplier)  LAZY                 Throws exception returned by supplier  |
+-----------------------------------------------------------------------------------------+

The orElse vs. orElseGet Performance Pitfall

[!WARNING] Eager vs. Lazy Evaluation: orElse(T other) evaluates its fallback expression eagerly at the moment the method call is made, regardless of whether the Optional is present or empty. In contrast, orElseGet(Supplier<? extends T> supplier) is evaluated lazily—the supplier is executed only if the Optional is empty. Calling expensive operations (database calls, web requests) inside orElse() wastes resources.

public static String computeDefault() {
    System.out.println("computeDefault() CALLED");
    return "GeneratedDefault";
}

Optional<String> presentOpt = Optional.of("ExistingValue");

// orElse: computeDefault() IS EXECUTED even though presentOpt contains a value!
String r1 = presentOpt.orElse(computeDefault()); // Prints "computeDefault() CALLED", returns "ExistingValue"

// orElseGet: computeDefault() is NEVER executed because presentOpt is present
String r2 = presentOpt.orElseGet(OptionalDemo::computeDefault); // Prints nothing, returns "ExistingValue"

orElseThrow Variations

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

// Java 10+ No-arg orElseThrow (preferred over get())
// String s1 = missing.orElseThrow(); // Throws NoSuchElementException: No value present

// Custom Exception with Supplier
// String s2 = missing.orElseThrow(() -> new IllegalArgumentException("User ID not found"));

---

4. Transforming and Chaining Optional Pipelines

Optional acts as a monad, providing fluent pipeline transformations without null-checks:

1. filter(Predicate<? super T> predicate)

If a value is present and matches the predicate, returns the Optional; otherwise returns Optional.empty().

Optional<String> opt = Optional.of("admin");
Optional<String> filtered = opt.filter(s -> s.startsWith("a")); // Optional["admin"]
Optional<String> rejected = opt.filter(s -> s.length() > 10);   // Optional.empty

2. map(Function<? super T, ? extends U> mapper)

If present, applies the mapper. If the mapping result is null, returns Optional.empty(). Automatically wraps non-null results in an Optional<U>.

Optional<String> title = Optional.of("oracle java se 21");
Optional<Integer> length = title.map(String::length); // Optional[17]

3. flatMap(Function<? super T, ? extends Optional<? extends U>> mapper)

If the mapping function itself returns an Optional, map() would produce a nested Optional<Optional<U>>. flatMap() flattens the result into a single Optional<U>.

class Address { private String zip; public Optional<String> getZip() { return Optional.ofNullable(zip); } }
class User { private Address address; public Optional<Address> getAddress() { return Optional.ofNullable(address); } }

User user = new User();
// Using flatMap to traverse nested Optionals safely
Optional<String> zipCode = Optional.of(user)
    .flatMap(User::getAddress)
    .flatMap(Address::getZip);

4. or(Supplier<? extends Optional<? extends T>> supplier) (Java 9+)

If present, returns this. If empty, evaluates the supplier producing a fallback Optional<T>.

Optional<String> primaryCache = Optional.empty();
Optional<String> secondaryCache = Optional.of("CachedData");

Optional<String> finalResult = primaryCache.or(() -> secondaryCache);
System.out.println(finalResult.get()); // "CachedData"

5. stream() (Java 9+)

Converts the Optional<T> into a Stream<T> containing either 1 element (if present) or 0 elements (if empty). Ideal for filtering and unwrapping collections of Optionals.

List<Optional<String>> optionalList = List.of(Optional.of("A"), Optional.empty(), Optional.of("B"));
List<String> presentValues = optionalList.stream()
    .flatMap(Optional::stream) // Unwraps present values and discards empty optionals
    .toList(); // ["A", "B"]

---

5. Primitive Optional Specializations

Just as with functional interfaces, Java provides three primitive specializations to avoid autoboxing overhead: OptionalInt, OptionalLong, and OptionalDouble.

[!IMPORTANT] No Functional Combinators on Primitive Optionals: OptionalInt, OptionalLong, and OptionalDouble do not support map(), flatMap(), filter(), or(), or stream(). If you need monadic chaining, you must map the primitive stream or box the value into Optional<Integer>.

---

6. Architectural Best Practices & Anti-Patterns

1. DO NOT use Optional for Class Fields: Optional does not implement java.io.Serializable. Using it for fields increases memory overhead and breaks serialization.
2. DO NOT use Optional for Method Parameters: Passing Optional as a method argument forces callers to wrap values and complicates API design. Use method overloading or nullable arguments instead.
3. DO NOT wrap Collections in Optional: Never return Optional<List<T>> or Optional<Map<K,V>>. Return an empty collection (Collections.emptyList()) instead.
4. Avoid Calling get() Unconditionally: Calling opt.get() without checking isPresent() is equivalent to risking a NullPointerException (it throws NoSuchElementException). Prefer orElse, orElseGet, orElseThrow, or ifPresent.