详细分析Java中的Optional类以及应用场景

前言

在实战中学习，灵活运用每个操作类，具体如下：

1. 基本知识

源码主要如下：

大致含义如下：

这是一个容器对象，可能包含或不包含非空值。如果有值存在，isPresent() 方法将返回 true，而 get() 方法将返回该值。
提供了一些依赖于包含值的存在或缺失的其他方法，例如 orElse()（如果值不存在，则返回默认值）和 ifPresent()（如果存在值，则执行一段代码块）。
这是一个基于值的类；在 Optional 实例上使用依赖于身份的操作（包括引用相等性（==）、身份哈希码或同步）可能会产生不可预测的结果，应该避免使用。
自 Java 1.8 起。

用开发的角度来讲，该类是 Java 8 中引入的一个用于处理可能为 null 的值的容器类。

它的设计目的是为了解决在代码中频繁出现的空指针异常问题。

不过这个类有好有坏，适当使用即可，其缺点就是造成代码过于冗长（= - = ）
最主要是引入额外的对象开销。

了解基本的特性以及薄弱项之后，站在后端的角度灵活运用其API以及常用方法

2. 常用API

创建Optional的对下你个有以下三种方式：

1. Optional.of(value): 创建一个包含非空值的 Optional 对象
   如果传递的值为 null，会抛出 NullPointerException

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

2. Optional.ofNullable(value): 创建一个 Optional 对象，如果传递的值为 null，仍然会创建一个空的 Optional 对象

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

3. Optional.empty(): 创建一个空的 Optional 对象

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

常用的操作方法如下:

1. isPresent(): 判断 Optional 对象是否包含非空值

if (optional.isPresent()) {
    // 做一些操作
}

2. ifPresent(Consumer consumer): 如果 Optional 对象包含非空值，则执行传入的操作

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

3. orElse(T other): 如果 Optional 对象包含非空值，则返回该值；否则返回传入的默认值

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

4. orElseGet(Supplier other): 类似于 orElse，但是默认值是由传入的 Supplier 提供的

String result = optional.orElseGet(() -> generateDefaultValue());

5. orElseThrow(Supplier exceptionSupplier): 如果 Optional 对象为空，则抛出由传入的 Supplier 提供的异常

String result = optional.orElseThrow(() -> new NoSuchElementException("Value not present"));

链式操作：Optional 提供了一些方法，在不解包 Optional 的情况下进行链式操作（这有助于避免空指针异常，并使代码更加清晰）

比如如下例子： nullableValue 不为 null，则将其转换为大写；否则，返回默认值 "Default"

String result = Optional.ofNullable(nullableValue)
                        .map(String::toUpperCase)
                        .orElse("Default");

3. Demo

通过示例的Demo操作上述的方法

import java.util.Optional;
public class Demo {
    public static void main(String[] args) {
        // 示例1: 创建包含非空值的 Optional 对象
        Optional<String> nonNullOptional = Optional.of("码农, 研究僧!");

        // 示例2: 创建可能为空值的 Optional 对象
        String nullableValue = null;
        Optional<String> optional = Optional.ofNullable(nullableValue);

        // 示例3: 使用 isPresent 判断是否包含非空值
        if (nonNullOptional.isPresent()) {
            System.out.println("Non-null value: " + nonNullOptional.get()); // 此处有空值，为true，输出 Non-null value: 码农, 研究僧!
        } else {
            System.out.println("Non-null value is not present.");
        }

        // 示例4: 使用 ifPresent 执行操作，没有空值才会执行！
        nonNullOptional = Optional.of("码农, 研究僧!");
        nonNullOptional.ifPresent(value -> System.out.println("Value from optional: " + value)); // 没有空值，就会输出 Value from optional: 码农, 研究僧!

        // 示例5: 使用 orElse 获取值或默认值
        String result = optional.orElse("Default Value");
        System.out.println("Result from orElse: " + result); // 输出默认值 Result from orElse: Default Value

        // 示例6: 使用 orElseGet 获取值或由 Supplier 提供的默认值
        String resultFromSupplier = optional.orElseGet(() -> generateDefaultValue());
        System.out.println("Result from orElseGet: " + resultFromSupplier); // 输出Supplier提供的默认值

        // 示例7: 使用 orElseThrow 抛出异常
        try {
            String resultOrThrow = optional.orElseThrow(() -> new RuntimeException("Value not present"));
            System.out.println("Result from orElseThrow: " + resultOrThrow);
        } catch (RuntimeException e) {
            System.out.println("Exception caught: " + e.getMessage()); // 此处对象为空，所以输出了这语句 Exception caught: Value not present
        }

        // 示例8: 链式操作
        String chainedResult = Optional.ofNullable(nullableValue)
                .map(String::toUpperCase)
                .orElse("Default Chain");
        System.out.println("Chained result: " + chainedResult); // 输出默认值：Chained result: Default Chain
    }

    private static String generateDefaultValue() {
        return "Default Value from Supplier";
    }
}

截图如下：

4. 应用场景

应用场景一般用于方法返回值或者集合操作中

场景一：

当方法的返回值可能为 null 时，使用 Optional 可以清晰地表达这一点，并要求调用者明确处理可能的空值情况

public Optional<String> findUserById(String userId) {
    // 在数据库中查找用户，可能返回 null
    // 使用 Optional 封装返回值
    // 返回 Optional.ofNullable(user) 或 Optional.empty()
}

场景二：

在对集合进行操作时，某些操作可能返回 null（例如在查找元素时）。
使用 Optional 可以更好地处理这些情况，而不是直接返回 null

public Optional<String> findFirstEvenNumber(List<Integer> numbers) {
    // 在集合中查找第一个偶数，可能返回 null
    // 使用 Optional 封装返回值
    // 返回 Optional.ofNullable(evenNumber) 或 Optional.empty()
}

场景三：

在防御性编程中，通过使用 Optional 可以更好地处理可能为 null 的值，避免空指针异常

public Optional<String> getUserName(User user) {
    // 获取用户的名称，用户对象可能为 null
    // 使用 Optional 封装返回值
    // 返回 Optional.ofNullable(userName) 或 Optional.empty()
}

场景四：

设计自己的 API 时，如果某个方法的返回值可能为空，使用 Optional 可以使 API 更加健壮和易于理解。

public Optional<Product> findProductById(String productId) {
    // 根据产品ID查找产品，产品可能不存在
    // 使用 Optional 封装返回值
    // 返回 Optional.ofNullable(product) 或 Optional.empty()
}

场景五：

当处理多层嵌套的对象时，使用 Optional 可以避免深层次的 null 检查，使代码更加简洁

public Optional<String> getAddressCity(User user) {
    // 获取用户地址的城市，用户、地址对象可能为 null
    // 使用 Optional 封装返回值
    // 返回 Optional.ofNullable(city) 或 Optional.empty()
}

虽然看起来很新鲜， 可以提高代码的健壮性，但需要注意不要滥用

主要如下，还是重点讲讲：

1. 造成代码冗长，本来一个null值就可以解决
2. 引入多一个对象多一个开销，如果本身追求速度，就不用刻意这样
3. 再者如果嵌套多层对象还这么使用，开发的可能感觉很牛，看的同事可能觉得臭臭臭臭臭

在某些情况下，直接使用 null 可能是更简单和清晰的选择
使用 Optional 主要是为了增加对空值的明确处理，使代码更加防御性和易读