Java Optional — Eliminate NullPointerException

NullPointerException (NPE) is the most common runtime error in Java. Optional<T>, introduced in Java 8, is a container that may or may not hold a value — forcing you to handle the absent case explicitly.

---

The Problem

// Without Optional — NPE waiting to happen
String city = getUser(id).getAddress().getCity();
// What if getUser returns null? Or getAddress returns null?

---

Creating an Optional

import java.util.Optional;

// 1. Known non-null value
Optional<String> present = Optional.of("Hello");

// 2. Possibly null value
Optional<String> maybe = Optional.ofNullable(getUserName()); // may be empty

// 3. Explicitly empty
Optional<String> empty = Optional.empty();

Optional.of(null) throws NullPointerException. Use ofNullable() when the value might be null.

---

Checking and Retrieving

Optional<String> opt = Optional.of("Java");

opt.isPresent()     // true
opt.isEmpty()       // false (Java 11+)

opt.get()           // "Java" — but throws NoSuchElementException if empty!

Avoid get() without checking first. Prefer the methods below.

---

Safe Retrieval

orElse() — Default Value

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

orElseGet() — Lazy Default

String name = opt.orElseGet(() -> computeDefault());

orElseGet() only calls the supplier when the Optional is empty — use it when the default is expensive to compute.

orElseThrow() — Throw If Empty

String name = opt.orElseThrow();  // NoSuchElementException
String name = opt.orElseThrow(() ->
    new IllegalStateException("Name is required"));

---

ifPresent() — Conditional Action

opt.ifPresent(name -> System.out.println("Hello, " + name));

// Java 9+
opt.ifPresentOrElse(
    name -> System.out.println("Hello, " + name),
    () -> System.out.println("No name provided")
);

---

Transforming with map()

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

Optional<String> trimmed = name.map(String::strip);
// Optional["Alice"]

Optional<Integer> length = name.map(String::strip).map(String::length);
// Optional[5]

If the Optional is empty, map() returns Optional.empty() without calling the function.

---

flatMap() — Unwrap Nested Optionals

When the mapping function itself returns an Optional:

public Optional<String> getCity(User user) {
    return Optional.ofNullable(user.getCity());
}

// map would give Optional<Optional<String>> — wrong!
// flatMap gives Optional<String> — correct!
Optional<String> city = optionalUser.flatMap(this::getCity);

---

filter() — Conditional Filtering

Optional<String> longName = Optional.of("Alexander")
    .filter(name -> name.length() > 5);
// Optional["Alexander"]

Optional<String> shortName = Optional.of("Bob")
    .filter(name -> name.length() > 5);
// Optional.empty

---

or() — Alternative Optional (Java 9+)

Optional<String> result = primaryLookup()
    .or(() -> secondaryLookup())
    .or(() -> Optional.of("default"));

---

stream() — Convert to Stream (Java 9+)

List<Optional<String>> optionals = List.of(
    Optional.of("A"), Optional.empty(), Optional.of("C"));

List<String> values = optionals.stream()
    .flatMap(Optional::stream)
    .toList();
// ["A", "C"]

---

Chaining Example — Null-Safe Navigation

// Before Optional
String city = null;
if (user != null && user.getAddress() != null) {
    city = user.getAddress().getCity();
}
if (city == null) city = "Unknown";

// With Optional
String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

---

When to Use Optional

✅ Good Uses

• Method return types when absence is a valid outcome:

public Optional<User> findById(long id) {
    return Optional.ofNullable(userMap.get(id));
}

• Stream terminal operations (findFirst(), findAny(), reduce())

❌ Anti-Patterns — Don’t Do These

// 1. Don't use as a field
private Optional<String> name;  // BAD — use null or default

// 2. Don't use as a method parameter
void process(Optional<String> name) { }  // BAD — just accept String

// 3. Don't use with collections
Optional<List<String>> items;  // BAD — return empty list instead

// 4. Don't use get() without checking
opt.get();  // BAD — throws if empty

// 5. Don't use for simple null checks
if (Optional.ofNullable(x).isPresent()) { }  // BAD — just use: if (x != null)

---

Optional with Primitive Types

Avoid autoboxing overhead with specialised Optionals:

OptionalInt    oi = OptionalInt.of(42);
OptionalLong   ol = OptionalLong.of(100L);
OptionalDouble od = OptionalDouble.of(3.14);

int value = oi.orElse(0);

---

Common Mistakes

Mistake	Problem	Fix
Optional.of(null)	NPE at creation	Use ofNullable()
opt.get() without check	NoSuchElementException	Use orElse()
Optional as field type	Serialisation issues, overhead	Use plain nullable field
Optional as parameter	Awkward API	Accept plain type
isPresent() + get()	Verbose, defeats purpose	Use map/orElse

---

Key Takeaways

1. Optional represents a value that may or may not be present.
2. Use ofNullable() when the value might be null.
3. Prefer orElse(), map(), ifPresent() over get().
4. Use flatMap() when the mapper returns an Optional.
5. Use Optional for return types only — not fields, not parameters.
6. Return empty collections instead of Optional<List<T>>.

---

What’s Next?

Final chapter: Java Records — immutable data carriers with auto-generated equals(), hashCode(), and toString().