In Java’s java.util.Optional class, you can work with nullable and non-null values using methods such as of(), ofNullable(), and empty(). Here’s an explanation of these methods and how to use them:

---

1. Using Optional.of(T value)

• Purpose: Used when the value you want to wrap is guaranteed to be non-null.
• Behavior: Throws a NullPointerException if the provided value is null.
• Example:

String value = "Hello, World!";
Optional<String> optional = Optional.of(value);  // Wrapping non-null value
// If value is null:
// Optional<String> optional = Optional.of(null); // Throws NullPointerException

---

2. Using Optional.ofNullable(T value)

• Purpose: Used when the value you want to wrap might be null.
• Behavior: Wraps the value in an Optional if it’s non-null, or returns an empty Optional if it’s null.
• Example:

String value = "Optional example";
Optional<String> optional1 = Optional.ofNullable(value);  // Creates Optional with value

String nullValue = null;
Optional<String> optional2 = Optional.ofNullable(nullValue);  // Returns Optional.empty

---

3. Using Optional.empty()

• Purpose: Explicitly creates an empty Optional object (an instance where no value is present).
• Behavior: Returns a “no value present” Optional, equivalent to an Optional created with ofNullable(null).
• Example:

Optional<String> optional = Optional.empty();  // Always represents "no value"

---

Summary of When to Use These Methods

Method	Use When	Behavior
Optional.of()	You know the value is non-null and want to wrap it.	Throws NullPointerException if the value is null.
Optional.ofNullable()	You want to wrap values that could be null.	Wraps non-null values; returns Optional.empty() for null.
Optional.empty()	You explicitly want an empty Optional to represent “no value”.	Always returns an empty Optional instance.

---

Example Code to Compare Them

package org.kodejava.util;

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        // Using Optional.of
        String nonNullValue = "Hello";
        Optional<String> ofOptional = Optional.of(nonNullValue);
        System.out.println("Optional.of: " + ofOptional);

        // Using Optional.ofNullable
        String nullableValue = null;
        Optional<String> nullableOptional = Optional.ofNullable(nullableValue);
        System.out.println("Optional.ofNullable: " + nullableOptional);

        // Using Optional.empty
        Optional<String> emptyOptional = Optional.empty();
        System.out.println("Optional.empty: " + emptyOptional);
    }
}

Output:

Optional.of: Optional[Hello]
Optional.ofNullable: Optional.empty
Optional.empty: Optional.empty

---

Keynotes:

• Always use ofNullable() when you’re working with values that can be null to avoid NullPointerException.
• Use of() for strict non-null values where you expect no nulls at runtime.
• Use empty() directly if you wish to return a guaranteed empty Optional.