Java 8 - 可选类

在 Java 8 中，引入了一个新的类 Optional，该类可以包装一个可能为 null 的对象，从而避免出现 NullPointerException 异常。本文将介绍 Java 8 中的 Optional 类，并给出一些其应用场景的例子。

Optional 类

Optional 类的创建

• 使用静态方法 of 创建一个特定值的 Optional 对象。

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

• 使用静态方法 empty 创建一个空的 Optional 对象。

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

• 使用静态方法 ofNullable 创建一个可能为空的 Optional 对象。

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

Optional 类的常用方法

• isPresent() - 如果值存在，返回 true，否则返回 false。

Optional<String> optional = Optional.of("Java 8 Optional");
System.out.println(optional.isPresent()); // 输出 true

• get() - 如果值存在，返回该值，否则抛出 NoSuchElementException 异常。

Optional<String> optional = Optional.of("Java 8 Optional");
System.out.println(optional.get()); // 输出 Java 8 Optional

• orElse(T other) - 如果值存在，返回该值，否则返回 other。

Optional<String> optional = Optional.of("Java 8 Optional");
String str = optional.orElse("default");
System.out.println(str); // 输出 Java 8 Optional

Optional<String> optional2 = Optional.empty();
String str2 = optional2.orElse("default");
System.out.println(str2); // 输出 default

• orElseGet(Supplier<? extends T> other) - 如果值存在，返回该值，否则返回 other 函数计算的结果。

Optional<String> optional = Optional.of("Java 8 Optional");
String str = optional.orElseGet(() -> "default");
System.out.println(str); // 输出 Java 8 Optional

Optional<String> optional2 = Optional.empty();
String str2 = optional2.orElseGet(() -> "default");
System.out.println(str2); // 输出 default

• orElseThrow(Supplier<? extends X> exceptionSupplier) - 如果值存在，返回该值，否则抛出由 exceptionSupplier 函数计算的异常。

Optional<String> optional = Optional.of("Java 8 Optional");
String str = optional.orElseThrow(() -> new RuntimeException("value is not present"));
System.out.println(str); // 输出 Java 8 Optional

Optional<String> optional2 = Optional.empty();
String str2 = optional2.orElseThrow(() -> new RuntimeException("value is not present"));

• filter(Predicate<? super T> predicate) - 如果值存在，并且该值满足 predicate 函数所需的条件，则返回一个 Optional 对象，否则返回一个空 Optional 对象。

Optional<Integer> optional = Optional.of(10);
Optional<Integer> result = optional.filter(i -> i > 5);
System.out.println(result.get()); // 输出 10

Optional<Integer> optional2 = Optional.of(2);
Optional<Integer> result2 = optional2.filter(i -> i > 5);
System.out.println(result2.isPresent()); // 输出 false

• map(Function<? super T, ? extends U> mapper) - 如果值存在，则对该值应用 mapper 函数，并返回一个 Optional 对象，否则返回一个空 Optional 对象。

Optional<String> optional = Optional.of("Java 8 Optional");
Optional<Integer> result = optional.map(String::length);
System.out.println(result.get()); // 输出 15

Optional<String> optional2 = Optional.empty();
Optional<Integer> result2 = optional2.map(String::length);
System.out.println(result2.isPresent()); // 输出 false

• flatMap(Function<? super T, Optional<U>> mapper) - 如果值存在，则对该值应用 mapper 函数，并返回一个 Optional 对象，否则返回一个空 Optional 对象。

Optional<String> optional = Optional.of("Java 8 Optional");
Optional<Integer> result = optional.flatMap(str -> Optional.of(str.length()));
System.out.println(result.get()); // 输出 15

Optional<String> optional2 = Optional.empty();
Optional<Integer> result2 = optional2.flatMap(str -> Optional.of(str.length()));
System.out.println(result2.isPresent()); // 输出 false

Optional 类的应用场景

空指针判断

在平时的编程中我们经常需要进行空指针判断，这时就可以使用 Optional 对象来避免出现 NullPointerException 异常。

public List<Integer> parseIntList(List<String> strList) {
    return strList.stream()
            .map(Optional::ofNullable)
            .map(optional -> optional.map(Integer::parseInt))
            .filter(Optional::isPresent)
            .map(Optional::get)
            .collect(Collectors.toList());
}

配置项读取

在读取配置项时，往往存在一些配置项是可选的，此时我们可以使用 Optional 对象来避免在配置项为空时出现异常。

Properties properties = new Properties();
properties.load(new FileInputStream("config.properties"));
String url = Optional.ofNullable(properties.getProperty("url")).orElse("default");
String username = Optional.ofNullable(properties.getProperty("username")).orElse("default");
String password = Optional.ofNullable(properties.getProperty("password")).orElse("default");

数据库查询

在数据库查询中，往往存在查询结果为空的情况，此时我们可以使用 Optional 对象来避免在查询结果为空时出现异常。

public Optional<User> findById(Long id) {
    // ...
    User user = queryForObject(sql, params, new BeanPropertyRowMapper<>(User.class));
    return Optional.ofNullable(user);
}