Java Optional Class

Container object that may or may not contain a non-null value to avoid NullPointerException

java (8+) 2025-11-03 optional null-safety java8 functional

Description

The Optional class was introduced in Java 8 to provide a better way to handle potentially null values. It encourages explicit null handling and reduces the risk of NullPointerException.

Key Principles

  • Never null: Optional itself should never be null
  • Empty or present: An Optional either contains a value or is empty
  • Functional operations: Provides map, filter, flatMap operations
  • OrElse methods: Provide fallback values

Best Practices

  • Use Optional for return types, not for fields or parameters
  • Avoid nesting Optionals (Optional<Optional>)
  • Don’t use Optional.get() without checking isPresent()
  • Prefer orElse() and orElseGet() over get()
  • Use Optional.empty() and Optional.of() appropriately

Code

RAW 
import java.util.Optional;import java.util.function.*;public class OptionalUtils {        // Safe value extraction    public static <T> T getValue(Optional<T> optional, T defaultValue) {        return optional.orElse(defaultValue);    }        // Safe value extraction with supplier    public static <T> T getValue(Optional<T> optional, Supplier<T> supplier) {        return optional.orElseGet(supplier);    }        // Throw exception if empty    public static <T> T getValueOrThrow(Optional<T> optional, String message) {        return optional.orElseThrow(() -> new IllegalArgumentException(message));    }        // Map operation    public static <T, R> Optional<R> map(Optional<T> optional, Function<T, R> mapper) {        return optional.map(mapper);    }        // Filter operation    public static <T> Optional<T> filter(Optional<T> optional, Predicate<T> predicate) {        return optional.filter(predicate);    }        // FlatMap operation    public static <T, R> Optional<R> flatMap(Optional<T> optional, Function<T, Optional<R>> mapper) {        return optional.flatMap(mapper);    }        // Conditional execution    public static <T> void ifPresent(Optional<T> optional, Consumer<T> action) {        optional.ifPresent(action);    }        // Conditional execution with else    public static <T> void ifPresentOrElse(Optional<T> optional, Consumer<T> action, Runnable emptyAction) {        optional.ifPresentOrElse(action, emptyAction);    }}
RAW 
// Creating OptionalsOptional<String> empty = Optional.empty();Optional<String> present = Optional.of("Hello");Optional<String> nullable = Optional.ofNullable(getString()); // may be null// Checking presenceif (present.isPresent()) {    String value = present.get();}// Safe value extractionString value1 = present.orElse("Default");String value2 = present.orElseGet(() -> "Default");String value3 = present.orElseThrow(() -> new RuntimeException("Not found"));// Map transformationOptional<Integer> length = present.map(String::length);Optional<String> upper = present.map(String::toUpperCase);// FilterOptional<String> filtered = present.filter(s -> s.length() > 5);// FlatMap (avoid Optional<Optional<T>>)Optional<String> flatMapped = present.flatMap(s -> Optional.of(s.toUpperCase()));// Conditional executionpresent.ifPresent(System.out::println);present.ifPresentOrElse(    System.out::println,    () -> System.out.println("Empty"));// Chaining operationsOptional<String> result = Optional.ofNullable(getString())    .filter(s -> !s.isEmpty())    .map(String::toUpperCase)    .orElse("DEFAULT");

Comments

No comments yet. Be the first to comment!