Optional源码解析
package java.util;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* 这是一个容器对象，它可能包含一个非空值，也可能不包含。
* 如果这个值存在，调用 isPresent() 方法会返回 true，调用 get() 方法会返回这个值。
*
* 还提供了一些其它方法，这些方法的运作依赖于值是否存在。例如：
* orElse()：如果值不存在，就返回一个默认值。
* ifPresent()：如果值存在，就执行一段代码。
*
* 这是一个基于值的类；在 Optional 类的实例上使用那些对身份敏感的操作（包括引用
* 相等性（==）、身份哈希码或同步）可能会产生不可预测的结果，所以应该避免这样做。
*
* 自从：Java 1.8版本以后
*/
public final class Optional<T> {
/**
* 一个用于表示空（empty）情况的通用实例。
*/
private static final Optional<?> EMPTY = new Optional<>();
/**
* 如果非空（non-null），存该值；如果空（null），则表示没有值存在。
*/
private final T value;
/**
* 创建一个空的实例。
*
* 通常，每个虚拟机（VM）中只应该存在一个空实例，即 EMPTY。
*/
private Optional() {
this.value = null;
}
/**
* 返回一个空的 Optional 实例。这个 Optional 没有值。
* 返回：一个空的 Optional
* API备注：尽管这样做可能很诱人，但避免通过与 Option.empty() 返回的实例使
* 用 == 进行比较来测试对象是否为空。不能保证它是一个单例。相反，使用 isPresent()
*/
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
/**
* 构建一个包含值的实例。
*
* 参数：value – 要存在的非空值
* 抛出：NullPointerException – 如果 value 是 null
*/
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}
/**
* 返回一个带有指定存在非空值的 Optional。
*
* 参数：value – 提供的指定值，必须是非空的
* 返回：一个带有指定值的 Optional
* 抛出：NullPointerException – 如果 value 是 null
*/
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
/**
* 返回一个描述指定值的 Optional，如果该值非空；否则返回一个空的 Optional。
*
* 参数：value – 可能为空的值
* 返回：如果指定的值非空，则返回一个带有值的 Optional；否则返回一个空的 Optional
*/
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
/**
* 如果这个 Optional 中有值，则返回该值，否则抛出 NoSuchElementException。
*
* 返回：这个 Optional 持有的非空值
* 抛出：NoSuchElementException – 如果没有值存在
*
* 参见：isPresent()
*/
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
/**
* 如果存在一个值，则返回 true，否则返回 false。
*
* 返回：如果存在一个值，则为 true，否则为 false
*/
public boolean isPresent() {
return value != null;
}
/**
* 如果存在一个值，则使用该值调用指定的处理者（处理这个值的代码块），否则不做任何操作。
*
* 参数：consumer – 如果存在值，则要执行的代码块
* 抛出：NullPointerException – 如果存在值，但处理者是 null
*/
public void ifPresent(Consumer<? super T> consumer) {
if (value != null)
consumer.accept(value);
}
/**
* 如果存在一个值，并且该值符合给定的条件，返回一个描述该值的 Optional，
* 否则返回一个空的 Optional。
*
* 参数：predicate – 一个条件，如果存在值，则应用于该值
* 返回：如果存在值并且该值符合给定条件，则返回描述这个 Optional 值的 Optional，
* 否则返回一个空的 Optional
* 抛出：NullPointerException – 如果条件是 null
*/
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}
/**
* 如果存在一个值，应用提供的映射函数到这个值上，如果结果是非空的，返回一个描述结果
* 的 Optional。否则返回一个空的 Optional。
*
* 参数：mapper – 一个映射函数，如果存在值，则应用于该值
*
* 返回：如果存在值，返回一个描述将映射函数应用于这个 Optional 的值的结果的 Optional，
* 否则返回一个空的 Optional
*
* 抛出：NullPointerException – 如果映射函数是 null
*
* API备注：这个方法支持对 Optional 值进行后处理，无需显式检查返回状态。
* 例如，以下代码遍历文件名流，选择一个尚未处理的文件名，然后打开该文件，
* 返回一个 Optional<FileInputStream>：
* Optional<FileInputStream> fis =
* names.stream().filter(name -> !isProcessedYet(name))
* .findFirst()
* .map(name -> new FileInputStream(name));
* 在这里，findFirst 返回一个 Optional<String>，然后如果存在所需的文件， map 返回一
* 个 Optional<FileInputStream>
*/
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Optional.ofNullable(mapper.apply(value));
}
}
/**
* 如果存在一个值，应用提供的返回 Optional 的映射函数到这个值上，返回那个结果；
* 否则返回一个空的Optional。这个方法类似于 map(Function)，但提供的映射器其结果
* 是已经是一个 Optional，如果被调用，flatMap 不会用额外的 Optional 包装它。
*
* 参数：mapper – 如果存在值，则应用映射函数到该值上
* 返回：如果存在值，返回应用一个返回 Optional 的映射函数到这个 Optional 的值的
* 结果，否则返回一个空的 Optional
* 抛出：NullPointerException – 如果映射函数是 null 或者返回了一个 null 结果
*/
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Objects.requireNonNull(mapper.apply(value));
}
}
/**
* 如果存在值，则返回该值；否则返回其它值。
*
* 参数：other – 如果没有值存在，则返回的值，可以是 null
* 返回：如果存在值，则为该值；否则为 other
*/
public T orElse(T other) {
return value != null ? value : other;
}
/**
* 如果存在值，则返回该值；否则调用 other 并返回其调用结果。
*
* 参数：other – 如果没有值存在，返回其结果的 Supplier
* 返回：如果存在值，则返回该值；否则返回 other.get() 的结果
* 抛出：NullPointerException – 如果值不存在且 other 是 null
*/
public T orElseGet(Supplier<? extends T> other) {
return value != null ? value : other.get();
}
/**
* 如果存在值，返回该值，否则抛出由提供者创建的异常。
*
* 参数：exceptionSupplier – 将返回要抛出的异常的提供者
*
* 返回：当前存在的值
*
* 抛出：X – 如果没有值存在；
NullPointerException – 如果没有值存在且 exceptionSupplier 是 null
*
* API备注：可以使用异常构造函数的引用作为提供者，该构造函数具有空参数列表。
* 例如，IllegalStateException::new
*/
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}
/**
* 指明某个其它对象是否“等于”这个 Optional。如果其它对象被认为是相等的，则：
* - 它也是一个 Optional 且两个实例都没有值存在；
* - 或者当前存在的值通过 equals() 方法被认为是“相等”的。
*
* 参数：obj – 要测试是否相等的对象
*
* 返回：如果其它对象“等于”这个对象，则返回 true，否则返回 false。
*/
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Optional)) {
return false;
}
Optional<?> other = (Optional<?>) obj;
return Objects.equals(value, other.value);
}
/**
* 如果存在值，则返回该值的哈希码值；如果没有值存在，则返回 0（零）。
*
* 返回：如果存在值，则为当前值的哈希码值；如果没有值存在，则为 0
*/
@Override
public int hashCode() {
return Objects.hashCode(value);
}
/**
* 返回这个 Optional 的非空字符串表示形式，适用于调试。
* 确切的呈现格式是未指定的，可能在实现和版本之间有所不同。
*
* 返回：这个实例的字符串表示形式
* 实现要求：
* - 如果存在值，结果必须在结果中包含其字符串表示。
* - 空的和存在的 Optional 必须能够明确区分。
*/
@Override
public String toString() {
return value != null
? String.format("Optional[%s]", value)
: "Optional.empty";
}
}
Optional示例解析
1.empty()
创建一个空的Optional实例。
import java.util.Optional;
// ERROR：java.util.Optional中的Optional()具有私有访问权限。
// Optional的构造方法是私有的，不能这样使用。目的是避免使用null。
// Optional<String> emptyOptional = new Optional<>();
Optional<String> emptyOptional = Optional.empty();
2.of()
创建一个包含非null值的Optional实例。
import java.util.Optional;
Optional<String> optional = Optional.of("Hello, World!");
// Optional.of()不能传null，会报NullPointerException异常
// Optional<String> optionalNull = Optional.of(null);
3.ofNullable()
创建一个可能为null的Optional实例。
import java.util.Optional;
String value1 = "Hello, World!";
Optional<String> optional1 = Optional.ofNullable(value1);
String value2 = null;
Optional<String> optional2 = Optional.ofNullable(value2);
4.get()
如果Optional中有值，则返回该值，否则抛出NoSuchElementException。
import java.util.Optional;
String value1 = "Hello, World!";
Optional<String> optional1 = Optional.ofNullable(value1);
System.out.println("optional1.get()：");
System.out.println(optional1.get());
String value2 = null;
Optional<String> optional2 = Optional.ofNullable(value2);
System.out.println("optional2.get()：");
System.out.println(optional2.get());
控制台输出：
optional1.get()：
Hello, World!
optional2.get()：
Exception in thread "main" java.util.NoSuchElementException: No value present
at java.util.Optional.get(Optional.java:135)
at com.baigezi.support.tool.OptionalDemo.main(OptionalDemo.java:14)
5.isPresent()
如果存在一个值，则返回 true，否则返回 false。
import java.util.Optional;
Optional<String> optional1 = Optional.ofNullable("Hello, World!");
System.out.println("optional1.isPresent()：");
System.out.println(optional1.isPresent());
Optional<String> optional2 = Optional.ofNullable(null);
System.out.println("optional2.isPresent()：");
System.out.println(optional2.isPresent());
控制台输出：
optional1.isPresent()：
true
optional2.isPresent()：
false
6.ifPresent(Consumer<? super T> consumer)
如果存在一个值，则使用该值调用指定的处理者（进行操作），否则不做任何操作。
import java.util.Optional;
import java.util.function.Predicate;
// 创建一个包含值的Optional实例
Optional<String> optional1 = Optional.of("Hello, World!");
// 创建一个空的Optional实例
Optional<String> optional2 = Optional.empty();
// 使用ifPresent方法处理值，这里的方法会执行，即输出相应值
optional1.ifPresent(value -> System.out.println("Value1 present: " + value));
// 使用ifPresent方法处理值，这里的方法不执行，即什么也不做
optional2.ifPresent(value -> System.out.println("Value2 present: " + value));
控制台输出：
Value1 present: Hello, World!
7.filter(Predicate<? super T> predicate)
接收一个 Predicate 函数式接口作为参数，用来对 Optional 包含的值进行条件判断。如果 Optional 包含一个值，并且这个值满足 Predicate 定义的条件，那么 filter 方法返回一个包含该值的 Optional 对象；如果 Optional 是空的或者包含的值不满足条件，那么返回一个空的 Optional 对象。如果传入的 Predicate 是 null，会抛出 NullPointerException。
import java.util.Optional;
import java.util.function.Predicate;
// 创建一个包含值的Optional实例
Optional<String> optional = Optional.of("Hello, World!");
// 定义一个条件，检查字符串是否以"Hello"开头
Predicate<String> startsWithHello = s -> s.startsWith("Hello");
// 使用filter方法检查值是否符合条件
Optional<String> filteredOptional = optional.filter(startsWithHello);
// 检查过滤后的Optional是否包含值
if (filteredOptional.isPresent()) {
System.out.println("optional的值符合条件: " + filteredOptional.get());
} else {
System.out.println("optional的值不符合条件或为空。");
}
// 尝试使用null的Predicate，这将抛出NullPointerException
// Optional<String> nullFilteredOptional = optional.filter(null);
控制台输出：
optional的值符合条件: Hello, World!
8.map(Function<? super T, ? extends U> mapper)
允许你将一个函数应用于Optional可能包含的值上，如果Optional包含一个值，那么这个值会被函数处理，否则返回一个空的Optional。
import java.util.Optional;
import java.util.function.Function;
// 创建一个包含字符串的Optional对象
Optional<String> optionalString = Optional.of("Hello, World!");
// 使用map方法将字符串映射为字符串的长度
Optional<Integer> optionalLength = optionalString.map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return s.length(); // 将字符串映射为其长度
}
});
// 打印结果
optionalLength.ifPresent(System.out::println); // 输出字符串的长度，即13
控制台输出：
13
9.flatMap(Function<? super T, Optional<U>> mapper)，
将 Optional 类型的对象中的值应用到一个函数上，并且这个函数返回的也是一个 Optional 类型的结果。如果 Optional 对象包含值，flatMap 会将这个值传递给提供的函数 mapper，并且返回函数的结果。如果 Optional 对象为空，flatMap 将直接返回一个空的 Optional 对象。这个方法通常用于链式调用，可以避免在每个步骤中都进行空值检查。
import java.util.Optional;
import java.util.function.Function;
Optional<String> optionalString = Optional.of("Hello, World!");
//Optional<String> optionalString = Optional.empty();
// 定义一个函数，它接受一个字符串，然后返回一个包含该字符串长度的 Optional<Integer>
Function<String, Optional<Integer>> stringToLength = s -> {
System.out.println("调用了stringToLength函数");
if (s == null || s.isEmpty()) {
return Optional.empty();
}
return Optional.of(s.length());
};
// 使用 flatMap 将 stringToLength 应用到 optionalString 上
Optional<Integer> optionalLength = optionalString.flatMap(stringToLength);
// 打印结果，如果 optionalString 包含非空字符串，将打印字符串的长度；
// 否则不调用stringToLength方法，不打印任何内容
optionalLength.ifPresent(System.out::println); // 输出：13
在这个例子中，optionalString 是一个包含字符串 “Hello, World!” 的 Optional 对象。我们定义了一个函数 stringToLength，它接受一个字符串并返回一个包含字符串长度的 Optional 对象。
然后我们使用 flatMap 方法将 stringToLength 应用到 optionalString 上。由于 optionalString 包含一个非空字符串，flatMap 将调用 stringToLength 并将 “Hello, World!” 作为参数传递给它。stringToLength 返回一个包含字符串长度的 Optional 对象，flatMap 将这个结果返回。
这时定义的optionalString是有值的，所以控制台输出为：
调用了stringToLength函数
13
如果 optionalString 是空的，flatMap 将直接返回一个空的 Optional 对象，而不会调用 stringToLength 函数：
//Optional<String> optionalString = Optional.of("Hello, World!");
Optional<String> optionalString = Optional.empty();
此时控制台没有任何输出。
10.orElse(T other)
如果存在值，则返回该值；否则返回提供值other。
import java.util.Optional;
Optional<String> optional1 = Optional.ofNullable("Hello, World!");
Optional<String> optional2 = Optional.ofNullable(null);
String defaultValue = "Default Value";
System.out.println(optional1.orElse(defaultValue));
System.out.println(optional2.orElse(defaultValue));
控制台输出：
Hello, World!
Default Value
11.orElseGet()
如果Optional对象中存在一个值（即value不为null），则返回这个值；如果不存在值（即value为null），则调用传入的Supplier对象的get方法，并返回其结果。
import java.util.Optional;
import java.util.function.Supplier;
Optional<String> optional1 = Optional.ofNullable("Hello, World!");
Optional<String> optional2 = Optional.ofNullable(null);
// 定义一个Supplier，当调用get方法时返回一个默认字符串
Supplier<String> defaultSupplier = () -> "Default Value";
// 使用orElseGet方法，如果optionalString有值则返回，否则调用defaultSupplier的get方法
String result1 = optional1.orElseGet(defaultSupplier);
String result2 = optional2.orElseGet(defaultSupplier);
System.out.println(result1);
System.out.println(result2);
控制台输出：
Hello, World!
Default Value
12.orElseThrow(Supplier<? extends X> exceptionSupplier) throws X
如果Optional对象中存在一个值（即value不为null），则返回这个值；如果不存在值（即value为null），则调用传入的exceptionSupplier的get方法来获取一个异常对象，并抛出这个异常。
import java.util.Optional;
try{
Optional<String> optional1 = Optional.ofNullable("Hello, World!");
Optional<String> optional2 = Optional.ofNullable(null);
// 使用orElseThrow方法，如果optional有值则返回，否则抛出一个由Supplier提供的异常
String result1 = optional1.orElseThrow(IllegalStateException::new);
System.out.println(result1);
String result2 = optional2.orElseThrow(IllegalStateException::new);
System.out.println(result2);
}catch (IllegalStateException e){
System.out.println("IllegalStateException");
}
控制台输出：
Hello, World!
IllegalStateException
13.equals(Object obj)
指明某个其它对象是否“等于”这个 Optional。如果其它对象被认为是相等的，则：
①它也是一个 Optional 且两个实例都没有值存在；
③当前存在的值通过 equals() 方法被认为是“相等”的。
import java.util.Optional;
Optional<String> optional1 = Optional.of("Hello");
Optional<String> optional2 = optional1;
Optional<String> optional3 = Optional.empty();
Optional<String> optional4 = Optional.empty();
Optional<String> optional5 = Optional.of("Hello");
Optional<String> optional6 = Optional.of("World");
// 比较optional1和optional2，它们是一个对象
boolean isEqual1 = optional1.equals(optional2); // 返回true
// 比较optional3和optional4，它们都没有值
boolean isEqual2 = optional3.equals(optional4); // 返回true
// 比较optional1和optional5，它们包含相同的字符串
boolean isEqual3 = optional1.equals(optional5); // 返回true
// 比较optional1和optional3，一个有值一个没值
boolean isEqual4 = optional1.equals(optional3); // 返回false
// 比较optional1和optional6，它们包含不同的字符串
boolean isEqual5 = optional1.equals(optional6); // 返回false
14.hashCode()
如果存在值，则返回该值的哈希码值；如果没有值存在，则返回 0。
import java.util.Optional;
Optional<String> optionalWithValue = Optional.of("Hello");
Optional<String> optionalWithoutValue = Optional.empty();
// 获取包含值的Optional对象的哈希码
// 返回"Hello"字符串的哈希码
int hashCodeWithValue = optionalWithValue.hashCode();
System.out.println(hashCodeWithValue);
// 获取不包含值的Optional对象的哈希码
// 返回0
int hashCodeWithoutValue = optionalWithoutValue.hashCode();
System.out.println(hashCodeWithoutValue);
控制台输出：
69609650
0
15.toString()
返回这个 Optional 的非空字符串表示形式。
import java.util.Optional;
Optional<String> optionalWithValue = Optional.of("Hello");
Optional<String> optionalWithoutValue = Optional.empty();
// 获取包含值的Optional对象的字符串表示形式
// 返回"Optional[Hello]"
String toStringWithValue = optionalWithValue.toString();
// 获取不包含值的Optional对象的字符串表示形式
// 返回"Optional.empty"
String toStringWithoutValue = optionalWithoutValue.toString();