Java Optional

Optional 是 Java 8 引入的一个容器类，用于表示可能包含或不包含非空值的对象。它主要用于避免 NullPointerException 并提供更优雅的空值处理方式。以下是一些常见的 Optional 用法示例

创建 Optional 对象

Optional.of(value)：创建一个包含非空值的 Optional 对象。

Optional.ofNullable(value)：创建一个可能包含空值的 Optional 对象。

Optional.empty()：创建一个空的 Optional 对象。

检查 Optional 是否包含值

isPresent()：如果 Optional 包含值，则返回 true。

ifPresent(Consumer<? super T> action)：如果 Optional 包含值，则执行给定的操作。

获取 Optional 的值

get()：如果 Optional 包含值，则返回该值，否则抛出 NoSuchElementException。

orElse(T other)：如果 Optional 包含值，则返回该值，否则返回默认值。

orElseGet(Supplier<? extends T> other)：如果 Optional 包含值，则返回该值，否则调用 Supplier 并返回其结果。

orElseThrow(Supplier<? extends X> exceptionSupplier)：如果 Optional 包含值，则返回该值，否则抛出由 Supplier 提供的异常。

转换 Optional 的值

map(Function<? super T, ? extends U> mapper)：如果 Optional 包含值，则应用映射函数并返回一个新的 Optional。

flatMap(Function<? super T, Optional<U>> mapper)：与 map 类似，但映射函数返回 Optional，不会嵌套 Optional。

示例

java

        import java.util.Optional;

public class OptionalExamples {

    public static void main(String[] args) {
        // 创建 Optional 对象
        Optional<String> nonEmptyOptional = Optional.of("Hello, World!");
        Optional<String> nullableOptional = Optional.ofNullable(null);
        Optional<String> emptyOptional = Optional.empty();

        // 检查 Optional 是否包含值
        System.out.println("nonEmptyOptional is present: " + nonEmptyOptional.isPresent());
        System.out.println("nullableOptional is present: " + nullableOptional.isPresent());
        System.out.println("emptyOptional is present: " + emptyOptional.isPresent());

        // 获取 Optional 的值
        System.out.println("nonEmptyOptional value: " + nonEmptyOptional.get());
        System.out.println("nullableOptional value or default: " + nullableOptional.orElse("Default Value"));
        System.out.println("emptyOptional value or default: " + emptyOptional.orElse("Default Value"));

        // 使用 ifPresent 执行操作
        nonEmptyOptional.ifPresent(value -> System.out.println("Value is present: " + value));

        // 转换 Optional 的值
        Optional<Integer> lengthOptional = nonEmptyOptional.map(String::length);
        System.out.println("Length of nonEmptyOptional value: " + lengthOptional.orElse(0));

        // 使用 flatMap 进行嵌套 Optional 的处理
        Optional<Optional<String>> nestedOptional = Optional.of(Optional.of("Nested Value"));
        Optional<String> flatMappedValue = nestedOptional.flatMap(opt -> opt);
        System.out.println("FlatMapped value: " + flatMappedValue.orElse("No Value"));
    }
}