Java Optional Class Explained — Stop Null Pointer Exceptions for Good

import java.util.Optional;

public class OptionalCreation {

    public static void main(String[] args) {

        // Scenario 1: We KNOW the username is not null (e.g. just fetched from an authenticated session)
        String authenticatedUsername = "alice";
        Optional<String> definitelyPresent = Optional.of(authenticatedUsername);
        System.out.println("Optional.of result: " + definitelyPresent);

        // Scenario 2: We have no result to return — maybe the search found nothing
        Optional<String> noResult = Optional.empty();
        System.out.println("Optional.empty result: " + noResult);

        // Scenario 3: Database lookup — the nickname column is nullable, so we use ofNullable
        String nicknameFromDatabase = null; // simulating a null column value
        Optional<String> maybeNickname = Optional.ofNullable(nicknameFromDatabase);
        System.out.println("Optional.ofNullable(null) result: " + maybeNickname);

        // Danger demo: Optional.of(null) throws immediately — do NOT do this
        try {
            Optional<String> danger = Optional.of(null); // <-- explodes here
        } catch (NullPointerException e) {
            System.out.println("Optional.of(null) threw NullPointerException as expected");
        }
    }
}

import java.util.Optional;

public class OptionalUnwrapping {

    // Simulates a user preference lookup — might return nothing if user hasn't set a theme
    static Optional<String> getUserThemePreference(String userId) {
        if ("user-42".equals(userId)) {
            return Optional.of("dark-mode");
        }
        return Optional.empty(); // user hasn't set a preference yet
    }

    public static void main(String[] args) {

        Optional<String> themeForKnownUser = getUserThemePreference("user-42");
        Optional<String> themeForNewUser = getUserThemePreference("user-99");

        // orElse: always evaluates the fallback expression (even if Optional is full)
        String knownUserTheme = themeForKnownUser.orElse("light-mode");
        System.out.println("Known user theme: " + knownUserTheme);

        // orElseGet: only calls the lambda if Optional is empty — preferred for expensive defaults
        String newUserTheme = themeForNewUser.orElseGet(() -> {
            System.out.println("  [Computing default theme from system config...]");
            return "system-default"; // imagine this queries a config service
        });
        System.out.println("New user theme: " + newUserTheme);

        // orElseThrow: when an empty Optional means something went seriously wrong
        try {
            String mustHaveTheme = themeForNewUser.orElseThrow(
                () -> new IllegalStateException("Theme must be configured before rendering")
            );
        } catch (IllegalStateException e) {
            System.out.println("Caught expected error: " + e.getMessage());
        }

        // ifPresent: cleanly execute logic only when a value exists — no null-check needed
        themeForKnownUser.ifPresent(theme ->
            System.out.println("Applying theme to UI: " + theme)
        );

        // ifPresentOrElse (Java 9+): handles both branches in one readable expression
        themeForNewUser.ifPresentOrElse(
            theme -> System.out.println("User theme: " + theme),
            ()    -> System.out.println("No theme set — showing onboarding prompt")
        );
    }
}

import java.util.Optional;

public class OptionalChaining {

    record Address(String street, String city, Optional<String> apartmentNumber) {}
    record User(String name, Optional<Address> address) {}

    // Simulates fetching a user from a database — some users might not exist
    static Optional<User> findUserById(int userId) {
        if (userId == 1) {
            Address home = new Address("123 Elm Street", "Springfield", Optional.of("4B"));
            return Optional.of(new User("Alice", Optional.of(home)));
        }
        if (userId == 2) {
            // User exists but hasn't set an address yet
            return Optional.of(new User("Bob", Optional.empty()));
        }
        return Optional.empty(); // user not found at all
    }

    public static void main(String[] args) {

        // --- map: transform a value inside Optional ---
        // Get the uppercased city for user 1 — each step is safe, no null checks needed
        String cityForAlice = findUserById(1)
            .map(User::address)          // Optional<User> -> Optional<Optional<Address>>
            // WRONG approach would stop here, but flatMap collapses the nesting:
            .flatMap(optAddr -> optAddr) // flatten Optional<Optional<Address>> -> Optional<Address>
            .map(Address::city)          // Optional<Address> -> Optional<String>
            .map(String::toUpperCase)    // Optional<String> -> Optional<String> (uppercased)
            .orElse("City not available");
        System.out.println("Alice's city: " + cityForAlice);

        // --- flatMap: essential when the transformer itself returns Optional ---
        // Apartment number is Optional<String> inside Address, so we flatMap it
        String apartmentForAlice = findUserById(1)
            .flatMap(User::address)              // Optional<User> -> Optional<Address>
            .flatMap(Address::apartmentNumber)   // Optional<Address> -> Optional<String>
            .orElse("No apartment number");
        System.out.println("Alice's apartment: " + apartmentForAlice);

        // --- Same chain for Bob who has no address — the whole pipeline gracefully returns empty ---
        String cityForBob = findUserById(2)
            .flatMap(User::address)
            .map(Address::city)
            .orElse("City not available");
        System.out.println("Bob's city: " + cityForBob);

        // --- filter: only proceed if the city name is longer than 5 characters ---
        boolean hasLongCityName = findUserById(1)
            .flatMap(User::address)
            .map(Address::city)
            .filter(city -> city.length() > 5)  // "Springfield" passes, "Roma" would not
            .isPresent();
        System.out.println("Alice has a long city name: " + hasLongCityName);

        // --- Non-existent user — the entire chain produces empty with no exceptions ---
        String cityForGhost = findUserById(999)
            .flatMap(User::address)
            .map(Address::city)
            .orElse("User not found");
        System.out.println("Ghost user's city: " + cityForGhost);
    }
}