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，你可以编写更安全和更可读的代码。