Optional in Java

// The OLD way (Before Java 8)
public class NullProblem {
    public static void main(String[] args) {
        String name = findUserName(123);
        // DANGER! What if name is null?
        System.out.println(name.toUpperCase());  // 💥 NullPointerException!
        // We had to write defensive code everywhere:
        if (name != null) {
            System.out.println(name.toUpperCase());  // Safe, but verbose
        }
        // Chained calls were a nightmare:
        User user = findUser(123);
        // Need to check every step!
        if (user != null) {
            Address address = user.getAddress();
            if (address != null) {
                String city = address.getCity();
                if (city != null) {
                    System.out.println(city.toUpperCase());
                }
            }
        }
        // SO MUCH CODE just to avoid null! 😫
    }
    static String findUserName(int id) {
        // Might return null if user not found
        return null;  // Whoops!
    }
    static User findUser(int id) {
        return null;  // User not found
    }
}
class User {
    Address getAddress() { return null; }
}
class Address {
    String getCity() { return null; }
}
// The problem: null is not explicit!
// You don't know if a method might return null until it crashes!

import java.util.Optional;
public class OptionalIntro {
    public static void main(String[] args) {
        // Optional wraps a value (or indicates absence)
        Optional<String> name = findUserName(123);
        // Now it's OBVIOUS that value might be absent!
        // Optional forces you to handle both cases:
        // Method 1: Check if present
        if (name.isPresent()) {
            System.out.println(name.get().toUpperCase());  // Safe!
        }
        // Method 2: Provide default value
        String userName = name.orElse("Guest");
        System.out.println(userName);  // Prints "Guest" if empty
        // Method 3: Functional style (elegant!)
        name.ifPresent(n -> System.out.println(n.toUpperCase()));
        // Benefits of Optional:
        // 1. Makes null-possibility explicit in API
        // 2. Forces you to think about the "no value" case
        // 3. Prevents NullPointerException
        // 4. Provides functional-style methods
        // Visual representation:
        // Traditional: String name = "Alice"  or  null  (ambiguous!)
        // Optional:    Optional<String> name = Optional.of("Alice")  (has value)
        //              Optional<String> name = Optional.empty()       (no value)
    }
    static Optional<String> findUserName(int id) {
        // Return Optional instead of null
        if (id == 123) {
            return Optional.of("Alice");
        }
        return Optional.empty();  // No user found (explicit!)
    }
}

import java.util.Optional;
public class CreatingOptional {
    public static void main(String[] args) {
        // Method 1: Optional.of() - Value MUST NOT be null
        Optional<String> opt1 = Optional.of("Hello");
        System.out.println(opt1);  // Optional[Hello]
        // Optional.of(null) throws NullPointerException!
        // Optional<String> bad = Optional.of(null);  // 💥 Crash!
        // Method 2: Optional.empty() - No value
        Optional<String> opt2 = Optional.empty();
        System.out.println(opt2);  // Optional.empty
        // Method 3: Optional.ofNullable() - Value CAN be null
        String maybeNull = null;
        Optional<String> opt3 = Optional.ofNullable(maybeNull);
        System.out.println(opt3);  // Optional.empty
        String notNull = "World";
        Optional<String> opt4 = Optional.ofNullable(notNull);
        System.out.println(opt4);  // Optional[World]
        // When to use which:
        // - Use of() when you're SURE value is not null
        // - Use empty() to explicitly indicate no value
        // - Use ofNullable() when value MIGHT be null (most common!)
        // Real-world examples:
        Optional<String> email = getUserEmail(123);  // Might not have email
        Optional<Integer> age = getUserAge(123);     // Might not have age
        Optional<String> phone = getUserPhone(123);  // Might not have phone
        // All three methods tell you: "This might not have a value!"
    }
    static Optional<String> getUserEmail(int userId) {
        // Simulate database lookup
        String email = null;  // User didn't provide email
        return Optional.ofNullable(email);
    }
    static Optional<Integer> getUserAge(int userId) {
        // Simulate database lookup
        Integer age = 25;  // User provided age
        return Optional.ofNullable(age);
    }
    static Optional<String> getUserPhone(int userId) {
        return Optional.empty();  // User didn't provide phone
    }
}

import java.util.Optional;
public class CheckingAndRetrieving {
    public static void main(String[] args) {
        Optional<String> present = Optional.of("Hello");
        Optional<String> empty = Optional.empty();
        // Method 1: isPresent() - Check if value exists
        if (present.isPresent()) {
            System.out.println("Value exists!");
        }
        if (!empty.isPresent()) {
            System.out.println("No value!");
        }
        // Method 2: isEmpty() - Check if empty (Java 11+)
        if (empty.isEmpty()) {
            System.out.println("Empty!");
        }
        // Method 3: get() - Get value (DANGEROUS if empty!)
        String value = present.get();  // "Hello"
        System.out.println(value);
        // ⚠️ WARNING: Never call get() without checking first!
        // String bad = empty.get();  // 💥 NoSuchElementException!
        // Method 4: orElse() - Provide default value
        String name = empty.orElse("Guest");
        System.out.println(name);  // Guest
        // Method 5: orElseGet() - Provide default via supplier (lazy!)
        String name2 = empty.orElseGet(() -> {
            System.out.println("Computing default...");
            return "Default User";
        });
        System.out.println(name2);
        // Difference: orElse vs orElseGet
        // orElse() - Default value ALWAYS computed (eager)
        String val1 = present.orElse(getDefaultName());  // Calls getDefaultName() even though value exists!
        // orElseGet() - Default value computed ONLY if needed (lazy)
        String val2 = present.orElseGet(() -> getDefaultName());  // Doesn't call getDefaultName()!
        // Method 6: orElseThrow() - Throw exception if empty
        try {
            String val = empty.orElseThrow(() -> new IllegalStateException("No value!"));
        } catch (IllegalStateException e) {
            System.out.println("Caught: " + e.getMessage());
        }
        // Method 7: ifPresent() - Execute action if value exists
        present.ifPresent(val -> System.out.println("Value is: " + val));
        empty.ifPresent(val -> System.out.println("This won't print"));
        // Method 8: ifPresentOrElse() - Do one thing if present, another if empty (Java 9+)
        present.ifPresentOrElse(
            val -> System.out.println("Found: " + val),
            () -> System.out.println("Not found")
        );
        // Best practices:
        // ✓ Use orElse() for simple defaults
        // ✓ Use orElseGet() for expensive defaults
        // ✓ Use ifPresent() for side effects
        // ✗ Avoid get() without isPresent() check
    }
    static String getDefaultName() {
        System.out.println("getDefaultName() called");
        return "Default";
    }
}

import java.util.Optional;
public class OptionalMethods {
    public static void main(String[] args) {
        // Method 1: map() - Transform value if present
        Optional<String> name = Optional.of("alice");
        Optional<String> upperName = name.map(String::toUpperCase);
        System.out.println(upperName.get());  // ALICE
        Optional<Integer> length = name.map(String::length);
        System.out.println(length.get());  // 5
        // map() on empty Optional returns empty Optional
        Optional<String> empty = Optional.empty();
        Optional<String> result = empty.map(String::toUpperCase);
        System.out.println(result);  // Optional.empty
        // Method 2: flatMap() - Transform value that returns Optional
        Optional<Person> person = Optional.of(new Person("Bob", 25));
        // Wrong: map() returns Optional<Optional<String>>
        // Optional<Optional<String>> nestedEmail = person.map(Person::getEmail);
        // Right: flatMap() flattens to Optional<String>
        Optional<String> email = person.flatMap(Person::getEmail);
        System.out.println(email.orElse("No email"));
        // Method 3: filter() - Keep value only if it matches condition
        Optional<Integer> age = Optional.of(25);
        Optional<Integer> adult = age.filter(a -> a >= 18);
        System.out.println(adult);  // Optional[25]
        Optional<Integer> senior = age.filter(a -> a >= 65);
        System.out.println(senior);  // Optional.empty
        // Method 4: or() - Provide alternative Optional if empty (Java 9+)
        Optional<String> primary = Optional.empty();
        Optional<String> backup = Optional.of("Backup");
        Optional<String> result2 = primary.or(() -> backup);
        System.out.println(result2.get());  // Backup
        // Chaining methods (functional style!)
        Optional<String> username = Optional.of("  ALICE  ");
        String processed = username
            .map(String::trim)           // Remove spaces: "ALICE"
            .map(String::toLowerCase)    // Lowercase: "alice"
            .filter(s -> s.length() > 3) // Keep if longer than 3
            .orElse("guest");            // Default if any step fails
        System.out.println(processed);  // alice
        // Real-world example: Processing user input
        Optional<String> userInput = Optional.ofNullable(getUserInput());
        String validatedInput = userInput
            .filter(s -> !s.isEmpty())           // Not empty
            .filter(s -> s.length() <= 100)      // Not too long
            .map(String::trim)                   // Clean up
            .map(String::toLowerCase)            // Normalize
            .orElseThrow(() -> new IllegalArgumentException("Invalid input"));
        System.out.println("Validated: " + validatedInput);
    }
    static String getUserInput() {
        return "  Hello World  ";
    }
}
class Person {
    private String name;
    private int age;
    private String email;
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    Optional<String> getEmail() {
        return Optional.ofNullable(email);  // Email might be null
    }
}

import java.util.*;
public class RealWorldOptional {
    // Example 1: Repository pattern
    static class UserRepository {
        private Map<Integer, User> users = new HashMap<>();
        UserRepository() {
            users.put(1, new User("Alice", "alice@email.com"));
            users.put(2, new User("Bob", null));  // Bob has no email
        }
        // Returns Optional - clear that user might not exist!
        Optional<User> findById(int id) {
            return Optional.ofNullable(users.get(id));
        }
        // Returns Optional - email might not exist!
        Optional<String> getEmailById(int id) {
            return findById(id)
                .flatMap(User::getEmail);
        }
    }
    // Example 2: Configuration values
    static class ConfigService {
        private Properties props = new Properties();
        ConfigService() {
            props.setProperty("app.name", "MyApp");
            // props doesn't have "app.version"
        }
        Optional<String> getProperty(String key) {
            return Optional.ofNullable(props.getProperty(key));
        }
        // With default value
        String getPropertyOrDefault(String key, String defaultValue) {
            return getProperty(key).orElse(defaultValue);
        }
    }
    // Example 3: Parsing user input
    static Optional<Integer> parseInteger(String str) {
        try {
            return Optional.of(Integer.parseInt(str));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }
    public static void main(String[] args) {
        UserRepository repo = new UserRepository();
        // Find user and print email
        repo.findById(1)
            .flatMap(User::getEmail)
            .ifPresentOrElse(
                email -> System.out.println("Email: " + email),
                () -> System.out.println("No email found")
            );
        // Chain multiple operations
        String displayName = repo.findById(1)
            .map(User::getName)
            .map(String::toUpperCase)
            .orElse("UNKNOWN");
        System.out.println("Display: " + displayName);
        // Config example
        ConfigService config = new ConfigService();
        String appName = config.getProperty("app.name")
            .orElse("Default App");
        System.out.println("App: " + appName);
        String version = config.getProperty("app.version")
            .orElse("1.0.0");
        System.out.println("Version: " + version);
        // Parsing example
        parseInteger("123")
            .ifPresent(num -> System.out.println("Valid number: " + num));
        parseInteger("abc")
            .ifPresentOrElse(
                num -> System.out.println("Valid: " + num),
                () -> System.out.println("Invalid number!")
            );
        // Complex example: Find user, get email, validate, send
        int userId = 1;
        repo.findById(userId)
            .flatMap(User::getEmail)
            .filter(email -> email.contains("@"))
            .ifPresentOrElse(
                email -> System.out.println("Sending email to: " + email),
                () -> System.out.println("Cannot send email to user " + userId)
            );
        // Example with Stream
        List<Integer> userIds = Arrays.asList(1, 2, 3, 4);
        List<String> emails = userIds.stream()
            .map(repo::findById)               // Stream<Optional<User>>
            .filter(Optional::isPresent)       // Keep only present
            .map(Optional::get)                // Get users
            .map(User::getEmail)               // Get Optional<String>
            .filter(Optional::isPresent)       // Keep only present
            .map(Optional::get)                // Get emails
            .collect(Collectors.toList());
        System.out.println("\nAll emails: " + emails);
    }
}
class User {
    private String name;
    private String email;
    User(String name, String email) {
        this.name = name;
        this.email = email;
    }
    String getName() {
        return name;
    }
    Optional<String> getEmail() {
        return Optional.ofNullable(email);
    }
}