java.util.Optional类介绍

java.util.Optional 是 Java 8 引入的一个容器类，用于表示可能包含或不包含非空值的对象。它的设计初衷是为了减少程序中的空指针异常（NullPointerException），并使代码更加简洁和易读。

Optional 类的介绍

1. 特点

• 避免显式的 null 检查：使用 Optional 可以避免显式的 null 检查，从而减少空指针异常。
• 提供有意义的返回值：当一个方法可能不返回有效值时，可以使用 Optional 作为返回类型，而不是返回 null。
• 更好的代码可读性：通过一组流式 API 方法，可以使代码更具可读性和表达力。

2. 主要方法

• empty(): 返回一个空的 Optional 实例。
• of(T value): 返回一个包含指定值的 Optional，如果值为 null 则抛出 NullPointerException。
• ofNullable(T value): 返回一个包含指定值的 Optional，如果值为 null 则返回一个空的 Optional。
• isPresent(): 如果值存在则返回 true，否则返回 false。
• ifPresent(Consumer<? super T> consumer): 如果值存在则执行指定的消费函数。
• get(): 如果值存在则返回该值，否则抛出 NoSuchElementException。
• orElse(T other): 如果值存在则返回该值，否则返回默认值。
• orElseGet(Supplier<? extends T> other): 如果值存在则返回该值，否则返回由 Supplier 提供的值。
• orElseThrow(Supplier<? extends X> exceptionSupplier): 如果值存在则返回该值，否则抛出由 Supplier 提供的异常。
• map(Function<? super T,? extends U> mapper): 如果值存在则对其应用提供的映射函数，并返回一个包含映射结果的 Optional，否则返回一个空的 Optional。
• flatMap(Function<? super T,Optional<U>> mapper): 如果值存在则对其应用提供的映射函数，并返回一个新的 Optional，否则返回一个空的 Optional。
• filter(Predicate<? super T> predicate): 如果值存在并且匹配给定的谓词，则返回该值，否则返回一个空的 Optional。

示例 1：基本使用

import java.util.Optional;

public class OptionalExample {

	public static void main(String[] args) {
		// 创建一个包含非空值的 Optional
        Optional<String> nonEmptyOptional = Optional.of("Hello, World!");

        // 创建一个可能为空的 Optional
        Optional<String> nullableOptional = Optional.ofNullable(null);

        // 创建一个空的 Optional
        Optional<String> emptyOptional = Optional.empty();

        // 检查值是否存在
        if (nonEmptyOptional.isPresent()) {
            System.out.println("Non-empty Optional contains: " + nonEmptyOptional.get());
        }

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

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

        // 获取值或通过供应函数获取默认值
        String valueFromSupplier = nullableOptional.orElseGet(() -> "Default Value from Supplier");
        System.out.println("Value from Supplier: " + valueFromSupplier);

        // 获取值或抛出异常
        try {
            String valueOrException = emptyOptional.orElseThrow(() -> new IllegalStateException("Value not present"));
        } catch (IllegalStateException e) {
            System.out.println(e.getMessage());
        }

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

        // 扁平映射值
        Optional<String> upperCaseOptional = nonEmptyOptional.flatMap(value2 -> Optional.of(value2.toUpperCase()));
        upperCaseOptional.ifPresent(upperCase -> System.out.println("Upper case: " + upperCase));

        // 过滤值
        Optional<String> filteredOptional = nonEmptyOptional.filter(value3 -> value3.startsWith("H"));
        filteredOptional.ifPresent(filteredValue -> System.out.println("Filtered value: " + filteredValue));
    }
}

示例 2：处理可能为空的返回值

import java.util.Optional;

public class UserService {
    public Optional<User> findUserById(String userId) {
        // 模拟一个可能返回空的查找操作
        if ("123".equals(userId)) {
            return Optional.of(new User("123", "Alice"));
        } else {
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        UserService userService = new UserService();
        Optional<User> userOptional = userService.findUserById("123");

        userOptional.ifPresent(user -> System.out.println("User found: " + user.getName()));

        User defaultUser = userOptional.orElse(new User("000", "Default User"));
        System.out.println("User: " + defaultUser.getName());

        User userFromSupplier = userOptional.orElseGet(() -> new User("000", "Default User from Supplier"));
        System.out.println("User from Supplier: " + userFromSupplier.getName());

        try {
            User userOrException = userOptional.orElseThrow(() -> new IllegalStateException("User not found"));
        } catch (IllegalStateException e) {
            System.out.println(e.getMessage());
        }
    }
}

class User {
    private String id;
    private String name;

    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

总结

Optional 类提供了一种优雅的方式来处理可能为空的对象，避免显式的 null 检查和潜在的空指针异常。通过使用 Optional，你可以编写更安全和更可读的代码。