Optional类与空值处理-JAVA 函数式编程入门与实践

当前位置:　首页>> 技术小册>> JAVA 函数式编程入门与实践

### 章节：Optional类与空值处理

在Java编程中，空值（null）是一个常见的概念，它用于表示某个变量或引用没有指向任何对象。然而，空值的广泛使用也带来了诸多问题，比如空指针异常（NullPointerException），它是Java程序中最常见的运行时异常之一。为了更安全、更优雅地处理空值，Java 8引入了`Optional`类，这是一个可以包含也可以不包含非null值的容器对象。使用`Optional`类可以显式地表示一个值存在或不存在，从而避免直接使用null可能导致的错误。

#### 1. Optional类简介

`Optional<T>`类是一个容器类，它可能包含也可能不包含非null的值。使用`Optional`类的主要目的是减少空指针异常的发生，使代码更加健壯、易于理解和维护。`Optional`类提供了一系列的方法来处理值的存在或缺失情况，如`isPresent()`, `ifPresent()`, `orElse()`, `orElseGet()`, `orElseThrow()`, `map()`, `flatMap()`等。

#### 2. 创建Optional对象

##### 2.1 使用`Optional.of(T value)`

当确定值不为null时，可以使用`Optional.of(T value)`方法创建`Optional`对象。如果传入的值为null，则会抛出`NullPointerException`。

```java
Optional<String> optionalString = Optional.of("Hello, Optional!");
System.out.println(optionalString.isPresent()); // 输出 true
```

##### 2.2 使用`Optional.ofNullable(T value)`

如果传入的值可能为null，应使用`Optional.ofNullable(T value)`方法。这个方法允许传入null值，如果传入null，则返回一个空的`Optional`对象。

```java
Optional<String> optionalNullString = Optional.ofNullable(null);
System.out.println(optionalNullString.isPresent()); // 输出 false
```

##### 2.3 使用`Optional.empty()`

如果你需要一个空的`Optional`对象，可以直接调用`Optional.empty()`方法。

```java
Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.isPresent()); // 输出 false
```

#### 3. 使用Optional对象

##### 3.1 检查值是否存在：`isPresent()`

`isPresent()`方法用于检查`Optional`对象是否包含值。如果包含值，则返回true；否则返回false。

```java
Optional<String> optional = Optional.of("Present");
if (optional.isPresent()) {
    System.out.println(optional.get()); // 输出 Present
}
```

##### 3.2 如果值存在，则执行操作：`ifPresent(Consumer<? super T> consumer)`

`ifPresent()`方法接受一个`Consumer`函数式接口的实现，如果值存在，则对该值执行给定的操作。

```java
Optional<String> optional = Optional.of("Present");
optional.ifPresent(System.out::println); // 输出 Present
```

##### 3.3 提供默认值：`orElse(T other)` 和 `orElseGet(Supplier<? extends T> other)`

- `orElse(T other)`：如果值存在，则返回该值；否则返回给定的默认值。
- `orElseGet(Supplier<? extends T> other)`：与`orElse`类似，但它是通过`Supplier`函数式接口生成默认值，这意味着默认值的计算是延迟的，只有在需要时才进行。

```java
Optional<String> optional = Optional.empty();
String defaultString = "Default";

// 使用 orElse
String resultOrElse = optional.orElse(defaultString);
System.out.println(resultOrElse); // 输出 Default

// 使用 orElseGet
String resultOrElseGet = optional.orElseGet(() -> defaultString.toUpperCase());
System.out.println(resultOrElseGet); // 输出 DEFAULT
```

##### 3.4 值不存在时抛出异常：`orElseThrow(Supplier<? extends X> exceptionSupplier)`

如果值不存在，`orElseThrow`方法允许你抛出一个自定义的异常。

```java
Optional<String> optional = Optional.empty();
try {
    String result = optional.orElseThrow(() -> new IllegalStateException("Value is not present"));
} catch (IllegalStateException e) {
    System.out.println(e.getMessage()); // 输出 Value is not present
}
```

##### 3.5 对值进行转换：`map(Function<? super T, ? extends U> mapper)` 和 `flatMap(Function<? super T, Optional<U>> mapper)`

- `map(Function<? super T, ? extends U> mapper)`：如果值存在，则对其执行给定的转换函数，并返回包含转换结果的新的`Optional`对象。
- `flatMap(Function<? super T, Optional<U>> mapper)`：与`map`类似，但转换函数返回的是`Optional<U>`类型，并且`flatMap`会将其“扁平化”处理，即如果转换结果为空的`Optional`，则直接返回空的`Optional`；否则返回包含转换结果的`Optional`。

```java
Optional<String> optionalString = Optional.of("Hello");

// 使用 map
Optional<Integer> optionalLength = optionalString.map(String::length);
System.out.println(optionalLength.get()); // 输出 5

// 使用 flatMap，这里只是为了演示，实际转换可能更复杂
Optional<Optional<Integer>> optionalOptionalLength = Optional.of(optionalString)
        .flatMap(s -> Optional.of(s.length()));
System.out.println(optionalOptionalLength.get()); // 输出 5
```

#### 4. Optional类的最佳实践

1. **避免在返回值中使用null**：尽量使用`Optional`代替null作为方法的返回值，以明确表明该值可能不存在。
2. **尽早返回Optional**：在方法体中，一旦计算出Optional值，就应该立即返回，而不是进行更多的计算或逻辑判断。
3. **使用Optional的流式处理**：利用`map`、`flatMap`等方法链式调用，可以优雅地处理复杂的数据转换逻辑。
4. **谨慎使用orElseThrow**：虽然`orElseThrow`允许在值不存在时抛出异常，但应谨慎使用，以避免滥用异常控制流程。
5. **避免在Optional中嵌套Optional**：`flatMap`方法允许你“扁平化”嵌套的Optional，但应尽量避免在设计中产生嵌套的Optional，因为它会使代码难以理解和维护。

#### 5. 总结

`Optional`类是Java 8引入的一个非常重要的特性，它提供了一种更好的处理空值的方式，使得代码更加健壮、易于理解和维护。通过合理使用`Optional`类及其提供的方法，我们可以显著减少空指针异常的发生，提高程序的稳定性和可靠性。然而，需要注意的是，`Optional`并不是万能的，它并不能完全替代所有的null检查逻辑。在实际编程中，我们应根据具体情况选择最适合的处理方式。

该分类下的相关小册推荐：

Mybatis合辑2-Mybatis映射文件

Java语言基础6-面向对象高级

Java语言基础8-Java多线程

深入拆解 Java 虚拟机

java源码学习笔记

Java面试指南

Java语言基础1-基础知识

Java语言基础10-Java中的集合

Java必知必会-Maven高级

Mybatis合辑4-Mybatis缓存机制

Java语言基础7-Java中的异常

Java语言基础4-数组详解