Java的Optional入门用法

Java 的 Optional 类是一种容器对象，包含了可能是或不是非空值的值。它主要用于减少代码中的 null 检查和 NullPointerException 的风险。Optional 类在 Java 8 中引入，位于 java.util 包中。

以下是关于 Optional 的一些重要方法和使用示例：

创建 Optional 对象

1. 使用 of 方法：

   Optional<String> optional = Optional.of("Hello");
   

   如果传递给 of 方法的值为 null，则会抛出 NullPointerException。

2. 使用 ofNullable 方法：

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

   ofNullable 方法允许传递 null 值，并创建一个空的 Optional 对象。

3. 使用 empty 方法：

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

   这将创建一个明确的空 Optional 对象。

检查 Optional 的值

1. 使用 isPresent 方法：

   if (optional.isPresent()) {
       System.out.println("Value is present");
   }
   

2. 使用 ifPresent 方法：

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

   如果值存在，ifPresent 方法会执行传递的 Consumer 函数。

获取 Optional 的值

1. 使用 get 方法：

   String value = optional.get();
   

   如果值不存在，调用 get 方法会抛出 NoSuchElementException。

2. 使用 orElse 方法：

   String value = optional.orElse("Default Value");
   

   如果值不存在，返回默认值。

3. 使用 orElseGet 方法：

   String value = optional.orElseGet(() -> "Default Value");
   

   orElseGet 方法与 orElse 类似，但接受一个 Supplier 函数。

4. 使用 orElseThrow 方法：

   String value = optional.orElseThrow(() -> new IllegalArgumentException("Value is missing"));
   

   如果值不存在，orElseThrow 方法会抛出指定的异常。

转换 Optional 的值

1. 使用 map 方法：

   Optional<Integer> lengthOptional = optional.map(String::length);
   

   map 方法会应用传递的函数并返回一个新的 Optional。

2. 使用 flatMap 方法：

   Optional<Integer> lengthOptional = optional.flatMap(value -> Optional.of(value.length()));
   

   flatMap 方法与 map 类似，但它会直接返回嵌套的 Optional 对象。

示例代码

以下是一个综合示例，展示了 Optional 的一些常见用法：

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> optional = Optional.ofNullable("Hello");

        // 检查值是否存在
        if (optional.isPresent()) {
            System.out.println("Value is present: " + optional.get());
        }

        // 使用 ifPresent
        optional.ifPresent(value -> System.out.println("Value: " + value));

        // 获取值，使用默认值
        String value1 = optional.orElse("Default Value");
        System.out.println("Value1: " + value1);

        // 获取值，使用 Supplier
        String value2 = optional.orElseGet(() -> "Default Value");
        System.out.println("Value2: " + value2);

        // 获取值，抛出异常
        try {
            String value3 = optional.orElseThrow(() -> new IllegalArgumentException("Value is missing"));
            System.out.println("Value3: " + value3);
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 转换值
        Optional<Integer> lengthOptional = optional.map(String::length);
        lengthOptional.ifPresent(length -> System.out.println("Length: " + length));

        // 平展 Optional
        Optional<Integer> flatMappedLengthOptional = optional.flatMap(value -> Optional.of(value.length()));
        flatMappedLengthOptional.ifPresent(length -> System.out.println("FlatMapped Length: " + length));
    }
}

Optional 类的引入大大增强了代码的可读性和安全性，减少了空指针异常的风险。在日常编程中合理使用 Optional 可以让代码更加健壮。