Optional.of vs ofNullable vs empty — When to Use Each

Three factory methods on Optional, each with different null semantics:

1. `Optional.of(value)`

• Wraps a value that's guaranteed non-null
• Throws `NullPointerException` immediately if value is null
• Use when you know the value is non-null and want to fail fast if your assumption breaks
• Example: returning a locally constructed object, returning a constant

2. `Optional.ofNullable(value)`

• Wraps a value that might be null
• Returns Optional.empty() if value is null, else wraps it
• Use when the value comes from an external source that could legitimately be null
• Example: Optional.ofNullable(map.get(key)), Optional.ofNullable(System.getProperty(...))

3. `Optional.empty()`

• Returns the canonical empty Optional — a cached singleton
• Use when you explicitly have no value to wrap
• Example: early-return when input is invalid; fallback when nothing was found

The decision rule

At the moment you call the factory, ask: do I KNOW this value is non-null?

• Yes → of (fail-fast if assumption breaks)
• Maybe → ofNullable (handle gracefully)
• Definitely no value → empty()

Why fail-fast matters

Using ofNullable defensively when of is appropriate masks bugs. If a service should always return a non-null Customer but someone breaks it, ofNullable silently converts null to empty — downstream you get "Anonymous" instead of "Alice" with no exception. With of, the bug surfaces immediately as an NPE in dev/test.

Rule: use of when null is a programming error; use ofNullable when null is a legitimate possibility.

Common patterns

• Wrap nullable JDK return: Optional.ofNullable(map.get(id))
• Wrap nullable env var: Optional.ofNullable(System.getenv("DB_URL"))
• Locally constructed and validated: Optional.of(receipt)
• Early-return absence: if (input == null) return Optional.empty();
• Stream's findFirst already returns Optional.empty() if no element

Pitfalls

• `Optional.of(null)` — NPE; use ofNullable if uncertain
• Returning `null` from an Optional method — critical bug; always return Optional.empty()
• `Optional.of("")` is not empty Optional — it wraps the empty string. To treat empty string as absent: Optional.of(s).filter(x -> !x.isEmpty())
• Defensive `ofNullable` everywhere — not safety; bug-masking
• `Optional.empty()` is allocation-free (cached singleton); use it freely

Recommendation: Be intentional about which factory you use. `Optional.of` for known non-null values (let it crash if your assumption breaks — that's a bug to fix, not hide). `Optional.ofNullable` for boundaries where null is a legitimate possibility (Map.get, env vars, legacy APIs). `Optional.empty()` for explicit early returns. Never use ofNullable defensively "just in case" — it masks real bugs and makes them harder to find. And never return null from a method declared to return Optional — that's the worst of all worlds: callers expect Optional and chain methods on it, getting an immediate NPE inside their .map(...). Always return Optional.empty().