Working with Optionals

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // THE PROBLEM: a method that returns null when nothing is found.
        // The caller has no warning that null is even possible.
        String found = findUser(99);          // returns null
        // System.out.println(found.length()); // 💥 NullPointerException!

        // THE FIX: return an Optional<String> instead of a bare String.
        // The TYPE now shouts "this might be empty — handle it".
        Optional<String> maybeUser = findUserSafely(99);
        System.out.println("Was a user found? " + maybeUser.isPresent());   // false

        // 3 ways to BUILD an Optional:
        Optional<String> a = Optional.of("Alice");      // value is NEVER null
        Optional<String> b = Optional.empty();          // deliberately nothing
        Optional<String> c = Optional.ofNullable(null); // value MIGHT be null

        System.out.println("of(\"Alice\")    -> isPresent? " + a.isPresent()); // true
        System.out.println("empty()         -> isPresent? " + b.isPresent()); // false
        System.out.println("ofNullable(null)-> isPresent? " + c.isPresent()); // false
        System.out.println("ofNullable(null)-> isEmpty?  " + c.isEmpty());    // true
    }

    static String findUser(int id) {
        return null;                            // the old, dangerous style
    }

    static Optional<String> findUserSafely(int id) {
        return Optional.empty();                // honest: "nothing here"
    }
}

Was a user found? false
of("Alice")    -> isPresent? true
empty()         -> isPresent? false
ofNullable(null)-> isPresent? false
ofNullable(null)-> isEmpty?  true

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name  = Optional.of("Alice");
        Optional<String> empty = Optional.empty();

        // get() — gives you the value, but is RISKY: it throws on an empty box.
        System.out.println("get() on present: " + name.get());   // Alice
        // empty.get();  // 💥 NoSuchElementException: No value present

        // orElse(default) — the default is ALWAYS built, even when not used.
        System.out.println("orElse: " + empty.orElse("Guest"));  // Guest

        // orElseGet(supplier) — the lambda only runs when the box is empty.
        // Use this when the default is expensive to create.
        System.out.println("orElseGet: " + empty.orElseGet(() -> "Lazy default"));

        // orElseThrow — turn "missing" into a clear exception of your choosing.
        try {
            empty.orElseThrow(() -> new IllegalStateException("No name set!"));
        } catch (IllegalStateException e) {
            System.out.println("orElseThrow caught: " + e.getMessage());
        }

        // PROOF that orElse is eager and orElseGet is lazy:
        // even though "name" is present, orElse still CALLS build()...
        name.orElse(build("orElse"));            // build() runs (wasteful)
        name.orElseGet(() -> build("orElseGet")); // build() is SKIPPED
    }

    static String build(String who) {
        System.out.println("  build() ran for " + who);
        return "x";
    }
}

get() on present: Alice
orElse: Guest
orElseGet: Lazy default
orElseThrow caught: No name set!
  build() ran for orElse

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        // 1) Wrap a value that is GUARANTEED non-null
        Optional<String> city = ___;          // 👉 use Optional.of with "Paris"

        // 2) Make an Optional that might be null (the value below could be null)
        String raw = null;
        Optional<String> maybe = ___;         // 👉 use Optional.ofNullable(raw)

        // 3) Unwrap "maybe" with a safe fallback of "Unknown"
        String result = maybe.___("Unknown"); // 👉 use orElse

        System.out.println("City: " + city.orElse("?"));
        System.out.println("Maybe: " + result);

        // ✅ Expected output:
        // City: Paris
        // Maybe: Unknown
    }
}

import java.util.Optional;

public class Main {
    record Address(String city) {}
    record User(String name, Address address) {}

    // findCity returns an Optional, so it must be flatMap-ed, not map-ed.
    static Optional<String> findCity(User u) {
        return Optional.ofNullable(u.address()).map(Address::city);
    }

    public static void main(String[] args) {
        Optional<User> user = Optional.of(new User("Alice", new Address("London")));

        // map() — transform the value INSIDE the box. Empty stays empty.
        Optional<String> upper = user.map(User::name).map(String::toUpperCase);
        System.out.println("map: " + upper.orElse("?"));        // ALICE

        // flatMap() — when your function already returns an Optional, flatMap
        // flattens Optional<Optional<String>> down to Optional<String>.
        Optional<String> city = user.flatMap(Main::findCity);
        System.out.println("flatMap: " + city.orElse("?"));     // London

        // filter() — keep the value only if it passes the test, else go empty.
        Optional<Integer> age = Optional.of(25);
        System.out.println("adult?  " + age.filter(n -> n >= 18).isPresent()); // true
        System.out.println("senior? " + age.filter(n -> n >= 65).isPresent()); // false

        // The whole point: one safe chain, no null checks, no NPE.
        String result = Optional.of(new User("Bob", null))
                .flatMap(Main::findCity)        // address is null -> empty
                .map(c -> "Lives in " + c)
                .orElse("City unknown");
        System.out.println(result);             // City unknown
    }
}

map: ALICE
flatMap: London
adult?  true
senior? false
City unknown

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        Optional<String> input = Optional.of("hello");

        // 1) Transform the value to UPPERCASE without unwrapping the box
        Optional<String> shouted = input.___(String::toUpperCase); // 👉 use map

        // 2) Keep it only if it is longer than 3 characters, else go empty
        Optional<String> longEnough = shouted.___(s -> s.length() > 3); // 👉 use filter

        // 3) Run code only if a value survived the filter
        longEnough.___(s -> System.out.println("Result: " + s)); // 👉 use ifPresent

        // ✅ Expected output:
        // Result: HELLO
    }
}

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name  = Optional.of("Alice");
        Optional<String> empty = Optional.empty();

        // ifPresent(consumer) — run code ONLY when a value exists. No else.
        name.ifPresent(n -> System.out.println("Hi, " + n + "!"));   // Hi, Alice!
        empty.ifPresent(n -> System.out.println("never runs"));      // (nothing)

        // ifPresentOrElse(consumer, runnable) — handle BOTH branches (Java 9+).
        name.ifPresentOrElse(
            n -> System.out.println("Found: " + n),                  // present
            () -> System.out.println("Nobody home")                  // empty
        );
        empty.ifPresentOrElse(
            n -> System.out.println("Found: " + n),
            () -> System.out.println("Nobody home")                  // this runs
        );
    }
}

Hi, Alice!
Found: Alice
Nobody home

import java.util.Optional;

public class Main {
    record Product(String name, String discountCode) {}

    // 🎯 MINI-CHALLENGE: Safely read a discount code
    // 1. A product's discountCode may be null. Wrap it with Optional.ofNullable.
    // 2. map it to uppercase, then filter to keep only codes that start with "SAVE".
    // 3. Use orElse to fall back to "NO-DISCOUNT" when there is no valid code.
    // 4. Print the final code for each product below.
    //
    // ✅ Expected output:
    // Phone: SAVE20
    // Cable: NO-DISCOUNT
    // Mouse: NO-DISCOUNT
    public static void main(String[] args) {
        Product[] products = {
            new Product("Phone", "save20"),   // valid -> SAVE20
            new Product("Cable", null),       // null  -> NO-DISCOUNT
            new Product("Mouse", "deal10"),   // wrong prefix -> NO-DISCOUNT
        };

        // your code here
    }
}