目录

前言1. 基本知识2. 常用API3. Demo4. 应用场景

前言

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

1. 基本知识

源码主要如下：

大致含义如下：

这是一个容器对象，可能包含或不包含非空值。如果有值存在，isPresent() 方法将返回 true，而 get() 方法将返回该值。

提供了一些依赖于包含值的存在或缺失的其他方法，例如 orElse()（如果值不存在，则返回默认值）和 ifPresent()（如果存在值，则执行一段代码块）。

这是一个基于值的类；在 Optional 实例上使用依赖于身份的操作（包括引用相等性（==）、身份哈希码或同步）可能会产生不可预测的结果，应该避免使用。

自 Java 1.8 起。

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

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

不过这个类有好有坏，适当使用即可，其缺点就是造成代码过于冗长（= - = ）

最主要是引入额外的对象开销。

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

2. 常用API

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

Optional.of(value): 创建一个包含非空值的 Optional 对象

如果传递的值为 null，会抛出 NullPointerException

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

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

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

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

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

👇

常用的操作方法如下:

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

if (optional.isPresent()) {

// 做一些操作

}

ifPresent(Consumer<? super T> consumer): 如果 Optional 对象包含非空值，则执行传入的操作

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

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

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

orElseGet(Supplier<? extends T> other): 类似于 orElse，但是默认值是由传入的 Supplier 提供的

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

orElseThrow(Supplier<? extends X> 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()

}

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

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

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

在某些情况下，直接使用 null 可能是更简单和清晰的选择

使用 Optional 主要是为了增加对空值的明确处理，使代码更加防御性和易读