The Optional Class

The Optional<T> class was introduced in Java 8 to address one of the most infamous problems in computer science: the NullPointerException (NPE), often referred to as the "Billion Dollar Mistake".

---

The Problem with Null

Before Java 8, if a method couldn't find a value to return, it would return null. It was entirely up to the developer to remember to write an if (result != null) check before using the object.

If they forgot, and tried to call a method on that null object, the entire application would instantly crash with a NullPointerException.

public class LabOptional1 {

  public static void main(String[] args) {
    // Imagine this method searches a database but finds nothing, returning null
    String username = findUserInDatabase("John");

    // CRASH! NullPointerException
    System.out.println("Name length: " + username.length());
  }

  static String findUserInDatabase(String name) {
    return null;
  }
}

---

The Solution: Optional<T>

Optional is a container object which may or may not contain a non-null value.

If a method returns an Optional, it is explicitly telling the developer: "Hey! I might not have a value to give you. You MUST handle the possibility of this being empty before you can access the data inside!"

It forces developers to deal with the absence of a value safely, completely eliminating accidental NPEs.

---

Creating Optionals

There are three ways to create an Optional object:

1. Optional.empty(): Creates an empty Optional (representing no value).
2. Optional.of(value): Creates an Optional containing a value. Warning: If the value passed is null, this will instantly throw a NullPointerException!
3. Optional.ofNullable(value): The safest method. If the value is not null, it wraps it. If the value is null, it gracefully returns an empty Optional.

---

Consuming Optionals Safely

Once you receive an Optional, how do you get the data out safely? Java provides several elegant methods, eliminating the need for if(x != null) checks.

1. The ifPresent() Method

Executes a Lambda (a Consumer) only if a value is present. If it's empty, it simply does nothing.

import java.util.Optional;

public class LabOptional2 {

  public static void main(String[] args) {
    Optional<String> nameOpt = Optional.ofNullable("Alice");
    Optional<String> emptyOpt = Optional.ofNullable(null);

    // Prints: "Found: Alice"
    nameOpt.ifPresent((name) -> System.out.println("Found: " + name));

    // Does absolutely nothing (Safe!)
    emptyOpt.ifPresent((name) -> System.out.println("Found: " + name));
  }
}

2. The orElse() Method

Returns the value if present. If it is empty, it returns a default value that you provide.

import java.util.Optional;

public class LabOptional3 {

  public static void main(String[] args) {
    Optional<String> emptyOpt = Optional.empty();

    // Extracts the value, or returns "Unknown User" if empty
    String finalName = emptyOpt.orElse("Unknown User");

    System.out.println(finalName); // Output: Unknown User
  }
}

3. The orElseThrow() Method

Returns the value if present. If it is empty, it throws an Exception that you specify (using a Supplier lambda).

import java.util.Optional;

public class LabOptional4 {

  public static void main(String[] args) {
    Optional<String> emptyOpt = Optional.empty();

    try {
      // Safely throw a custom exception instead of a random NullPointerException!
      String finalName = emptyOpt.orElseThrow(() ->
        new IllegalArgumentException("User not found!")
      );
    } catch (Exception e) {
      System.out.println(e.getMessage()); // Output: User not found!
    }
  }
}