Java8新特性：Optional 类_java8的optional好用么-CSDN博客

本文链接：https://blog.csdn.net/qq_33326733/article/details/139468035

在软件开发中，空指针异常（NPE，NullPointerException）是一个常见的问题，尤其在 Java 中。为了减少空指针异常的发生，Java 8 引入了 Optional 类。本文将通过源码和示例详细讲解 Optional 类的使用和实现原理，并比较其与传统方式的优缺点，以及与其他编程语言中类似实现的对比。

Optional 的诞生背景

Optional 类的引入是 Java 8 的重要改进之一，它的诞生背景主要是为了应对和解决在编程过程中经常遇到的空指针异常。空指针异常是 Java 编程中最常见的问题之一。

空指针异常的常见场景

在编程过程中，以下场景经常会导致空指针异常：

基本数据类型的自动拆箱：当返回类型为基本数据类型，而实际返回的是包装类型对象时，如果对象为 null，会引发空指针异常。

java
```
public int getIntegerValue() {
    Integer value = null;
    return value; // 会抛出 NullPointerException
}
```
数据库查询结果可能为 null：在数据库操作中，查询结果可能为空，使用时需要进行空值检查。

java
```
User user = userRepository.findById(id);
if (user != null) {
    // 处理 user
}
```

集合中的元素可能为 null：即使集合不为空，其内部的元素也可能为空。

java

List<String> list = new ArrayList<>();
list.add(null);
for (String item : list) {
    System.out.println(item.length()); // 会抛出 NullPointerException
}

远程调用返回对象时的空指针判断：远程调用（例如 RPC 调用）返回的对象可能为空，需要进行空值检查。

java
```
Result result = remoteService.call();
if (result != null) {
    // 处理 result
}
```
Session 中获取的数据可能为空：在 Web 应用中，从 Session 中获取的数据可能为空，需要进行空值检查。

java
```
HttpSession session = request.getSession();
User user = (User) session.getAttribute("user");
if (user != null) {
    // 处理 user
}
```
一连串的级联调用：当进行一连串的级联调用时，如果其中一个环节为空，会引发空指针异常。

java
```
String value = object.getA().getB().getC(); // 如果 getA() 或 getB() 返回 null，会抛出 NullPointerException
```

Optional 的设计目的

Optional 类的引入是为了更优雅和安全地处理这些可能为空的情况，具体目标包括：

显式地处理空值：通过 Optional，可以显式地表示一个值可能为空，迫使开发者在使用值之前检查其是否为空。
减少空指针异常：通过使用 Optional，可以减少代码中显式的空值检查，从而减少 NullPointerException 的发生。
提高代码的可读性和可维护性：使用 Optional 可以使代码更加简洁和易读，减少多层嵌套的空值检查逻辑。
提供更丰富和安全的 API：Optional 提供了一些有用的方法，如 map、flatMap、ifPresent 等，可以方便地处理包含值或空值的情况。

传统处理方式 vs Optional

Java 8 之前的处理方式

传统上，我们通过一系列的非空判断来防止空指针异常。假设有一个 Zoo 类，里面有一个 Dog 属性，需求是要获取 Dog 的 age。

java

class Zoo {
    private Dog dog;

    // Getter and Setter
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
}

class Dog {
    private int age;

    // Getter and Setter
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

使用传统方式获取 Dog 的 age 需要进行多层非空判断：

java

Zoo zoo = getZoo();
if (zoo != null) {
    Dog dog = zoo.getDog();
    if (dog != null) {
        int age = dog.getAge();
        System.out.println(age);
    }
}

虽然这种方式可以防止空指针异常，但代码显得啰嗦且不优雅。

使用 Optional

使用 Optional 可以简化上述代码，并显得更加优雅：

java

Optional.ofNullable(zoo)
        .map(Zoo::getDog)
        .map(Dog::getAge)
        .ifPresent(age -> System.out.println(age));

是不是简洁了很多呢？接下来，我们深入了解 Optional 是如何工作的。

如何创建一个 Optional

创建 Optional 的几种常用方法包括 ofNullable、of 和 empty。下面我们通过源码来逐一解析。

`Optional.ofNullable` 方法

java

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

如果传入的值为 null，返回一个空的 Optional；否则，返回包含该值的 Optional。

`Optional.empty` 方法

java

public static <T> Optional<T> empty() {
    return (Optional<T>) EMPTY;
}

empty 方法返回一个全局的空 Optional 实例 EMPTY。

`Optional.of` 方法

java

public static <T> Optional<T> of(T value) {
    return new Optional<>(Objects.requireNonNull(value));
}

of 方法要求传入的值不能为 null，否则会抛出 NullPointerException。

`Optional` 的构造方法

java

private Optional(T value) {
    this.value = Objects.requireNonNull(value);
}

构造方法中使用了 Objects.requireNonNull 方法来确保传入的值不为 null。

java

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

综合示例

综合以上，创建 Optional 的几种方式可以总结为：

java

Optional<String> optional1 = Optional.of("Hello"); // 不可为空
Optional<String> optional2 = Optional.ofNullable("Hello"); // 可为空
Optional<String> optional3 = Optional.empty(); // 空的 Optional

使用 Optional 的基本操作

`isPresent` 和 `ifPresent`

isPresent 用于检查 Optional 是否包含值：

java

Optional<String> optional = Optional.of("Hello");
if (optional.isPresent()) {
    System.out.println(optional.get());
}

ifPresent 提供了更优雅的做法：

java

optional.ifPresent(System.out::println);

`orElse` 和 `orElseGet`

orElse 和 orElseGet 用于提供默认值：

java

String value = optional.orElse("Default");
String value = optional.orElseGet(() -> "Default");

`map` 和 `flatMap`

map 和 flatMap 用于转换 Optional 中的值：

java

Optional<Integer> age = optional.map(String::length);

flatMap 适用于返回值仍为 Optional 的情况：

java

Optional<Integer> age = optional.flatMap(value -> Optional.of(value.length()));

使用场景和优点

防止空指针异常

Optional 的主要目的是防止空指针异常，特别适用于以下场景：

数据库查询结果可能为 null。
集合中的元素可能为空。
远程调用返回对象时进行空指针判断。
Session 中获取的数据可能为空。
级联调用时避免空指针异常。

更加简洁和安全的代码

使用 Optional 可以使代码更简洁，避免了多层非空判断，同时也更安全。

在高并发环境下确保 Optional 的性能

在高并发环境下，确保 Optional 的使用不会带来性能问题，主要需要关注以下几个方面：

避免不必要的对象创建

频繁创建和销毁 Optional 对象可能会对性能产生影响。在高并发环境下，尽量避免不必要的对象创建。

java

public Optional<String> getValue() {
    String value = fetchValueFromDatabase();
    return Optional.ofNullable(value);
}

// 在调用处，尽量重用 Optional 对象，而不是每次都创建新的 Optional
Optional<String> optionalValue = getValue();
if (optionalValue.isPresent()) {
    // 处理值
}

使用高效的流操作

简化流操作，避免不必要的计算可以提高性能。

java

Optional<String> optionalValue = getValue();
optionalValue.ifPresent(value -> {
    // 复杂的链式调用可能会影响性能
    Optional<Integer> length = optionalValue.map(String::length).filter(len -> len > 5);
    length.ifPresent(System.out::println);
});

// 简化后的操作
optionalValue.map(String::length)
             .filter(len -> len > 5)
             .ifPresent(System.out::println);

使用并行流（Parallel Stream）

在高并发场景中，可以考虑使用并行流来提高处理效率。

java

List<Optional<String>> list = Arrays.asList(Optional.of("A"), Optional.empty(), Optional.of("B"));

list.parallelStream()
    .flatMap(opt -> opt.map(Stream::of).orElseGet(Stream::empty))
    .forEach(System.out::println);

确保线程安全

在高并发环境下，确保 Optional 的使用是线程安全的。

java

private final Map<Integer, Optional<String>> cache = new ConcurrentHashMap<>();

public Optional<String> getCachedValue(int key) {
    return cache.getOrDefault(key, Optional.empty());
}

性能测试和监控

通过性能测试工具（如 JMH）和监控工具（如 JProfiler、VisualVM 等），可以实际测量和监控 Optional 使用带来的性能影响，从而进行优化调整。

java

import org.openjdk.jmh.annotations.*;

@State(Scope.Benchmark)
public class OptionalBenchmark {

    private Optional<String> optional;

    @Setup
    public void setup() {
        optional = Optional.of("Benchmark");
    }

    @Benchmark
    public void testOptionalGet() {
        optional.ifPresent(System.out::println);
    }
}

Optional 与其他编程语言的类似实现对比

在讨论 Java 的 Optional 与其他编程语言中的类似实现（如 Scala 的 Option、Kotlin 的 Nullable 类型）时，我们需要考虑设计哲学、功能特性和具体实现方式等多个方面。

设计哲学

Java 的 Optional

Java 的 Optional 设计初衷是为了解决空指针异常问题，同时提升代码的可读性和安全性。Optional 是一种包装器类型，表示一个值可能存在也可能不存在。Java 8 引入 Optional 主要是为了在流操作和函数式编程中提供更好的空值处理机制。

Scala 的 Option

Scala 的 Option 也是一种容器类型，可以包含一个值或不包含值。Scala 的 Option 被设计为一种更广泛的工具，不仅用于防止空指针异常，还用于函数式编程中处理可能失败的计算。

Kotlin 的 Nullable 类型

Kotlin 的 Nullable 类型通过类型系统本身解决了空指针异常的问题。Kotlin 在编译时就能够检查出可能的空指针异常，通过类型系统强制开发者进行空值处理。

功能特性对比

Java 的 Optional

不可变性：Optional 是不可变的，一旦创建就不能修改其值。
方法丰富：提供了 map、flatMap、filter、ifPresent、orElse、orElseGet 等方法，方便进行链式操作。
性能优化：在高并发环境下，Optional 的设计考虑了性能优化，但需要开发者自己注意避免频繁创建对象。

Scala 的 Option

模式匹配：Scala 的 Option 可以与模式匹配结合使用，提供更强大的语法支持。
scala
```
option match {
    case Some(value) => println(value)
    case None => println("None")
}
```
更丰富的集合操作：Scala 的 Option 集成了更多的集合操作方法，如 getOrElse、fold 等，适用于更复杂的数据处理需求。

Kotlin 的 Nullable 类型

类型系统支持：Kotlin 的 Nullable 类型直接集成在类型系统中，通过 ? 表示类型可以为空。
```
val value: String? = null
```
安全调用操作符：提供安全调用操作符 ?. 和 Elvis 操作符 ?:，简化空值判断和处理。
```
val length = value?.length ?: 0
```

具体实现方式

Java 的 Optional

Java 的 Optional 是一个最终类（final class），其内部维护了一个值，通过静态工厂方法（如 of、ofNullable、empty）进行创建。以下是部分源码的实现：

java

public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();
    private final T value;

    private Optional() {
        this.value = null;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    public static <T> Optional<T> empty() {
        return (Optional<T>) EMPTY;
    }
    
    // 其他方法...
}

Scala 的 Option

Scala 的 Option 是一个抽象类，有两个子类：Some 和 None。Some 包含一个值，None 表示没有值。

scala

sealed abstract class Option[+A] {
    // 方法定义
}

case class Some[+A](value: A) extends Option[A]
case object None extends Option[Nothing]

Kotlin 的 Nullable 类型

Kotlin 的 Nullable 类型是通过类型系统支持的，不是特定的类实现。编译器通过类型检查确保空值安全。

kotlin

val value: String? = null
val length: Int = value?.length ?: 0

独特之处总结

Java 的 Optional

设计初衷不同：Java 的 Optional 主要用于减少空指针异常，提高代码的安全性和可读性。相比之下，Scala 的 Option 和 Kotlin 的 Nullable 类型设计初衷更加广泛。
API 风格：Java 的 Optional 提供了一系列 API 方法，方便进行链式调用和流处理。这些方法与 Java 8 引入的流操作紧密结合。
性能考虑：在高并发环境下，Optional 的设计考虑了性能优化，但需要开发者自己注意避免频繁创建对象。