前言
在实战中学习,灵活运用每个操作类,具体如下:
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 主要是为了增加对空值的明确处理,使代码更加防御性和易读