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

目录

  • 前言
  • 1. 基本知识
  • 2. 常用API
  • 3. Demo
  • 4. 应用场景

前言

在实战中学习,灵活运用每个操作类,具体如下:
详细分析Java中的Optional类以及应用场景_第1张图片

1. 基本知识

源码主要如下:

详细分析Java中的Optional类以及应用场景_第2张图片

大致含义如下:

这是一个容器对象,可能包含或不包含非空值。如果有值存在,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!");
  1. Optional.ofNullable(value): 创建一个 Optional 对象,如果传递的值为 null,仍然会创建一个空的 Optional 对象
Optional<String> optional = Optional.ofNullable(someNullableValue);
  1. Optional.empty(): 创建一个空的 Optional 对象
Optional<String> emptyOptional = Optional.empty();

常用的操作方法如下:

  1. isPresent(): 判断 Optional 对象是否包含非空值
if (optional.isPresent()) {
    // 做一些操作
}
  1. ifPresent(Consumer consumer): 如果 Optional 对象包含非空值,则执行传入的操作
optional.ifPresent(value -> System.out.println("Value: " + value));
  1. orElse(T other): 如果 Optional 对象包含非空值,则返回该值;否则返回传入的默认值
String result = optional.orElse("Default Value");
  1. orElseGet(Supplier other): 类似于 orElse,但是默认值是由传入的 Supplier 提供的
String result = optional.orElseGet(() -> generateDefaultValue());
  1. 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";
    }
}

截图如下:

详细分析Java中的Optional类以及应用场景_第3张图片

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 主要是为了增加对空值的明确处理,使代码更加防御性和易读

你可能感兴趣的:(java,java,Optional,Null)