【java】java.util.Optional的用法

1. 说明

• 1.java.util.Optional 是 Java 8 引入的一个用于避免 NullPointerException 的容器类。
• 2.它代表一个值存在或不存在，并提供了一种更好的方式来处理可能为 null 的对象。
• 3.通过这些用法，Optional 类提供了一种优雅且安全的方式来处理可能为 null 的对象，从而减少了 NullPointerException 的风险。

2. 创建 Optional 对象

2.1 使用 Optional.of

• 1.如果传入 null，会抛出 NullPointerException。
• 2.示例

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

2.2 使用 Optional.ofNullable

• 1.Optional.ofNullable 可以接受 null，并且会返回一个空的 Optional 对象。
• 2.示例

Optional<String> optionalNullableString = Optional.ofNullable(null);
Optional<String> optionalStringWithValue = Optional.ofNullable("Hello, Optional with Nullable!");

3. 获取值

3.1 使用 get

• 1.如果 Optional 对象为空，会抛出 NoSuchElementException。
• 2.示例

String value = optionalString.get();

3.2 使用 orElse

• 1.如果 Optional 对象为空，会返回指定的默认值。
• 2.示例

String valueOrDefault = optionalNullableString.orElse("Default Value");

3.3 使用 orElseThrow

• 1.如果 Optional 对象为空，会抛出指定的异常。
• 2.代码示例

String valueOrThrow = optionalNullableString.orElseThrow(() -> new IllegalArgumentException("Value is missing!"));

4. 判断值是否存在

4.1 使用 isPresent

• 1.示例

boolean isPresent = optionalString.isPresent();

4.2 使用 ifPresent

• 1.如果 Optional 对象不为空，会执行给定的消费者函数。

• 2.示例

optionalString.ifPresent(value -> System.out.println("Value is present: " + value));

5. 映射和过滤

5.1 使用 map

• 1.如果 Optional 对象不为空，会对值应用给定的函数并返回一个新的 Optional 对象。
• 2.代码示例

Optional<Integer> optionalLength = optionalString.map(String::length);

5.2 使用 flatMap

• 1.flatMap 可以处理返回的 Optional 对象，并返回一个嵌套的 Optional。
• 2.代码示例

Optional<String> optionalUpperCase = optionalString.flatMap(value -> Optional.ofNullable(value.toUpperCase()));

5.3 使用 filter

• 1.如果 Optional 对象不为空且值满足给定的条件，则返回该 Optional 对象，否则返回一个空的 Optional 对象。
• 2.代码示例

Optional<String> optionalFiltered = optionalString.filter(value -> value.startsWith("Hello"));

6. 完整示例

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        // 创建 Optional 对象
        Optional<String> optionalString = Optional.ofNullable("Hello, Optional!");

        // 获取值
        String value = optionalString.orElse("Default Value");
        System.out.println("Value: " + value);

        // 判断值是否存在
        boolean isPresent = optionalString.isPresent();
        System.out.println("Is present: " + isPresent);

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

        // 映射
        Optional<Integer> optionalLength = optionalString.map(String::length);
        optionalLength.ifPresent(length -> System.out.println("Length: " + length));

        // 过滤
        Optional<String> optionalFiltered = optionalString.filter(value -> value.startsWith("Hello"));
        optionalFiltered.ifPresent(filteredValue -> System.out.println("Filtered Value: " + filteredValue));

        // 创建一个空的 Optional 对象
        Optional<String> optionalEmpty = Optional.empty();
        optionalEmpty.ifPresent(value -> System.out.println("This will not be printed"));

        // 使用 orElseThrow
        try {
            String valueOrThrow = optionalEmpty.orElseThrow(() -> new IllegalArgumentException("Value is missing!"));
        } catch (IllegalArgumentException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }
}