Optional

In Java, the Optional class is a feature introduced in Java 8 to help prevent the common problem of NullPointerException. An Optional is like a container that can hold a value or be empty, making it easier to check if a variable has a value before using it.

Why Use Optional?

Using Optional helps you:

• Avoid null values, reducing the chance of NullPointerException.
• Make your code cleaner and more readable.
• Clearly indicate when a method might not return a result.

Creating an Optional

You can create an Optional in a few different ways:

• Empty Optional: An empty Optional holds no value.

Optional<String> emptyOptional = Optional.empty();

• Optional with Value: Use of when you're sure the value is not null.

Optional<String> optionalWithValue = Optional.of("Hello, Java!");

• Optional with Possible Null: Use ofNullable when the value might be null.

Optional<String> optionalWithPossibleNull = Optional.ofNullable(null);

Checking and Using Optional Values

To safely work with the value inside an Optional, you can use methods like isPresent, ifPresent, or orElse.

• isPresent: Checks if there is a value present in the Optional.

if (optionalWithValue.isPresent()) {
    System.out.println(optionalWithValue.get()); // Prints "Hello, Java!"
}

• ifPresent: Executes a function only if a value is present.

optionalWithValue.ifPresent(value -> System.out.println("Value: " + value));

• orElse: Provides a default value if the Optional is empty.

String result = emptyOptional.orElse("Default Value");
System.out.println(result); // Prints "Default Value"

Other Useful Methods

• orElseGet: Similar to orElse, but lets you provide a function that runs only if the Optional is empty.

String result = emptyOptional.orElseGet(() -> "Generated Default");

• orElseThrow: Throws an exception if the Optional is empty.

String result = emptyOptional.orElseThrow(() -> new RuntimeException("No value present"));

• map: Transforms the value inside the Optional if it exists.

Optional<String> optionalUpper = optionalWithValue.map(String::toUpperCase);
optionalUpper.ifPresent(System.out::println); // Prints "HELLO, JAVA!"

Chaining with Optional

You can chain methods with Optional to handle values more elegantly, especially when dealing with multiple levels of nullable data.

Optional<String> name = Optional.ofNullable("John");
String result = name.map(String::toUpperCase).orElse("No Name");
System.out.println(result); // Prints "JOHN"