34. Optional: Beating the NullPointerException

[!NOTE] Sir Tony Hoare, the inventor of the null reference in 1965, famously refers to it as his "Billion Dollar Mistake". Because if you attempt to call a method on an object that is secretly null, your Java application instantly crashes with a NullPointerException (NPE).

The Classic Defensive Check Letdown

Historically, Java explicitly forced you to write endless defensive if (x != null) checks everywhere.

User user = database.findUser("sagar99");

// If the user wasn't in the DB, it returned null. 
// If you forget this check, the app catastrophically crashes on the next line!
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        String city = address.getCity(); // Safe!
    }
}

Meet Optional

Introduced in Java 8, Optional is a container object that either contains a non-null value, or essentially says "I am empty".

You change your method signatures to return an Optional<User> instead of a raw User. This acts as a giant flashing warning sign to the developer calling the method: "Hey! The user you are looking for might physically not exist. You MUST handle the empty state!"

import java.util.Optional;

public class OptionalDemo {
    // 1. Return an Optional wrapped object
    public static Optional<String> searchForFile(String name) {
        if (name.equals("secret.txt")) {
            return Optional.of("Found the text!"); // Wrap a real object
        } else {
            return Optional.empty(); // Returns a formal "Empty Box" instead of a chaotic null
        }
    }

    public static void main(String[] args) {
        Optional<String> result = searchForFile("missing.txt");
        
        // 2. Beautiful declarative handling!
        // We supply a default fallback string to use if the box was empty!
        String finalOutput = result.orElse("Fallback File Content");
        
        System.out.println(finalOutput); // Outputs: Fallback File Content
    }
}

Advanced Chaining

The true power of Optional is chaining it similarly to Streams, preventing massive pyramids of if statements.

// The old pyramid of doom is replaced entirely by this!
String city = database.findUser("sagar99")  // Returns Optional<User>
    .flatMap(User::getAddress)              // Unwraps user, gets Optional<Address>
    .map(Address::getCity)                  // Unwraps address, gets Optional<String>
    .orElse("Unknown City");                // The ultimate fallback if ANY step was empty!

Optional Is for Return Values, Not Everything

Optional is best used when a method may not return a value. It makes absence explicit. It is usually not recommended for fields, method parameters, or collections that can simply be empty.

Good Use

Optional<User> findUserByEmail(String email) {
    // return Optional.empty() when no user exists
}

Handling Absence Clearly

String displayName = findUserByEmail(email)
    .map(User::getDisplayName)
    .orElse("Guest");

orElse vs orElseGet

String value = optionalName.orElseGet(() -> loadDefaultName());

orElseGet is lazy. The fallback supplier runs only when the optional is empty. That matters when the fallback is expensive.

Common Mistakes

Calling get() without checking presence.
Returning null from a method declared to return Optional.
Wrapping collections in Optional instead of returning an empty collection.
Using Optional to hide unclear domain rules.

Mini Practice

Write a method that searches a list of usernames and returns Optional<String>. Print the found name in uppercase, or print Guest when missing.

Practice Lab: Safe User Search

Return Optional from a method where a value may be missing.

Create a list of usernames.
Write Optional<String> findUser(String username).
Return Optional.empty() when the user is missing.
Use map to uppercase a found username.
Use orElse to print Guest when missing.

Goal: Make missing data explicit and avoid raw null returns.

Revision Checkpoint

Optional: Represents a value that may be absent.
Best use: Return values where absence is expected.
orElse: Supplies fallback value.
map: Transforms present value.
Avoid: Calling get() blindly.

Before the quiz: Explain why returning Optional.empty() is clearer than returning null.