深入理解 lambda表达式与 Optional Null 源码解析（Java11 三）

1次阅读

共计 9582 个字符，预计需要花费 24 分钟才能阅读完成。

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.*;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
* @author 陈杨
*/

@RunWith(SpringRunner.class)
@SpringBootTest
public class OptionalTest {

@Test

public void testOptional() {
一、Optional 出现的缘由
/*
* A container object which may or may not contain a non-{@code null} value.
*
* 一个装泛型为 T 的值容器可以包含 Null 以规避空指针异常
* public final class Optional<T>
*/
二、深入理解 Value-based Classes
/*
* Value-based Classes
*
* https://docs.oracle.com/javase/8/docs/api/java/lang/doc-files/ValueBased.html
*
* final immutable (但里面可以包含指向可变对象的引用)
* 具有 equals、hashCode 和 toString 的实现仅从实例的状态计算而不是从其标识或任何其他对象或变量的状态计算
* 不使用身份敏感的操作，例如实例之间的引用相等（==）实例的 hashCode，或实例的内部锁（intrinsic lock）同步
* 判断是否相等仅比较 equals() 方法而非对象的引用（==）
* 没有可访问的构造函数通过工厂方法实例化，不保证实例创建的一致性（不一定是单例）
*
* 基于值的对象没有 public 的构造方法比较值是否相等（不比较引用）
*/
三、Optional 容器的构造
// private static final Optional<?> EMPTY = new Optional<>();
// private final T value;

// Constructs an empty instance.
// private Optional() { this.value = null;}

/*
* Constructs an instance with the described value.
*
* private Optional(T value) {this.value = Objects.requireNonNull(value); }
*/

/*
* Returns an empty {@code Optional} instance. No value is present for this {@code Optional}.
*
* public static<T> Optional<T> empty() {
* @SuppressWarnings(“unchecked”)
* Optional<T> t = (Optional<T>) EMPTY;
* return t;
* }
*/
Optional<List<String>> empty = Optional.empty();

/* 构造一个容器里不为 null 的容器对象
*
* public static <T> Optional<T> of(T value) {return new Optional<>(value); }
*/
Optional<List<String>> optional = Optional.of(Arrays.asList(“Kirito”, “Love”, “Asuna”));

/* 构造一个容器里可能为 null 的容器对象
*
* public static <T> Optional<T> ofNullable(T value) {return value == null ? empty() : of(value); }
*/
四、普通方法
/* 获取容器中的所有值
* public T get() {
* if (value == null) {
* throw new NoSuchElementException(“No value present”);
* }
* return value;
* }
*/
System.out.println(“—————————————\n”);
System.out.println(“optional 容器中存在的值:” + optional.get());

// 判断容器中存在值返回 true
// public boolean isPresent() { return value != null;}
System.out.println(“—————————————\n”);
System.out.println(“optional 容器中存在值：” + optional.isPresent());
System.out.println(“empty 容器中存在值:” + empty.isPresent());

// 判断容器中不存在值返回 true
// @since 11
// public boolean isEmpty() { return value == null;}
System.out.println(“—————————————\n”);
System.out.println(“optional 容器中不存在值：” + optional.isEmpty());
System.out.println(“empty 容器中不存在值：” + empty.isEmpty());
五、高级拓展
1、ifPresent（Consumer）
/*
* 如果存在 value 对 value 进行一个 Consumer 消费
* public void ifPresent(Consumer<? super T> action) {
* if (value != null) {
* action.accept(value);
* }
* }
*
*/
System.out.println(“—————————————\n”);
System.out.println(“optional 容器中存在值就进行 Consumer 消费（打印输出）”);
optional.ifPresent(System.out::println);
2、ifPresentOrElse（Consumer）
/* 如果存在 value 对 value 进行一个 Consumer 消费不存在执行 emptyAction（empty-based action）
* @since 9
* public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
* if (value != null) {
* action.accept(value);
* } else {
* emptyAction.run();
* }
* }
*/
System.out.println(“—————————————\n”);
System.out.println(“ 容器中存在值就打印值，不存在打印 hello world”);
optional.ifPresentOrElse(System.out::println, () -> System.out.println(“hello world”));
empty.ifPresentOrElse(System.out::println, () -> System.out.println(“hello world”));
3、filter（Predicate）
/*
* 如果存在 value 且符合预期 predicate 则对 value 进行预期操作 predicate.test(value) 否则返回 empty
* public Optional<T> filter(Predicate<? super T> predicate) {
* Objects.requireNonNull(predicate);
* if (!isPresent()) {
* return this;
* } else {
* return predicate.test(value) ? this : empty();
* }
* }
*/
System.out.println(“—————————————\n”);
System.out.println(“ 遍历集合元素 ”);
optional.filter(strings -> {
strings.forEach(System.out::println);
return true;
});
4、or(Supplier）
/*
* 如果存在 value 则返回 value 否则使用 supplier 接口的 get() 方法构造出一个 Optional
* @since 9
* public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
* Objects.requireNonNull(supplier);
* if (isPresent()) {
* return this;
* } else {
* @SuppressWarnings(“unchecked”)
* Optional<T> r = (Optional<T>) supplier.get();
* return Objects.requireNonNull(r);
* }
* }
*/
System.out.println(“—————————————\n”);
Supplier<Optional<List<String>>> sup =
() -> Optional.ofNullable(Arrays.asList(“Optional”, “or”, “supplier”));

System.out.println(empty.or(sup));
5、Stream.of（value）
/*
* 如果存在 value 则返回 Stream.of(value) 否则返回一个 Stream.empty()
* @since 9
* public Stream<T> stream() {
* if (!isPresent()) {
* return Stream.empty();
* } else {
* return Stream.of(value);
* }
* }
*/
System.out.println(“—————————————\n”);
System.out.println(“ 以 stream 流遍历 optional 容器内的值 ”);
Stream<List<String>> stream = Stream.of(optional.get());
stream.forEach(System.out::println);
6、orElse（T other）
/*
* 如果存在 value 则返回 value 否则返回 T other
* public T orElse(T other) {
* return value != null ? value : other;
* }
*/
System.out.println(“—————————————\n”);
System.out.println(” 容器中存在值就返回值不存在就返回 {\”hello\”,\”world\”}”);
System.out.println(empty.orElse(Arrays.asList(“hello”, “world”)));
7、orElseGet（Supplier）
/*
* 如果存在 value 则返回 value 否则返回 Supplier 接口实现
* public T orElseGet(Supplier<? extends T> supplier) {
* return value != null ? value : supplier.get();
* }
*/
System.out.println(“—————————————\n”);
Supplier<List<String>> listSupplier = () -> Arrays.asList(“do”, “orElseGet”);
System.out.println(empty.orElseGet(listSupplier));
8、orElseThrow
/*
* 如果存在 value 则返回 value 否则抛出异常 NoSuchElementException
* @since 10
* public T orElseThrow() {
* if (value == null) {
* throw new NoSuchElementException(“No value present”);
* }
* return value;
* }
*/
System.out.println(“—————————————\n”);
System.out.println(” 容器中存在值就返回值不存在就返回 NoSuchElementException”);

System.out.println(optional.orElseThrow());
try {
System.out.println(empty.orElseThrow());
} catch (NoSuchElementException e) {
System.out.println(” NoSuchElementException —> No value present”);
}
9、orElseThrow（Supplier）
/*
* 如果存在 value 则返回 value 否则使用 Supplier 接口生成一个被抛出的 exceptionSupplier –>exception
* public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
* if (value != null) {
* return value;
* } else {
* throw exceptionSupplier.get();
* }
* }
*/
System.out.println(“—————————————\n”);
Supplier<NoSuchElementException> noSuchElementException = NoSuchElementException::new;

try {
System.out.println(empty.orElseThrow(noSuchElementException));
} catch (NoSuchElementException e) {
System.out.println(” Supplier NoSuchElementException —> No value present”);
}
10、map（Function）
/*
*
* 如果存在 value 则返回 value 并作为 mapper 的输入将其输出作为新的 value 存放至 Optional 否则返回一个 null 的 Optional
* 如果经过 mapper 后得到的结果为 null 返回一个 null 的 Optional
* mapper 函数若为 null 则抛出 NullPointerException
* map：对集合中每个元素进行操作
*
*
* public Optional map(Function<? super T, ? extends U> mapper) {
* Objects.requireNonNull(mapper);
* if (!isPresent()) {
* return empty();
* } else {
* return Optional.ofNullable(mapper.apply(value));
* }
* }
*/
System.out.println(“—————————————\n”);
Function<List<String>, List<String>> function =
up -> up.stream().map(String::toUpperCase).collect(Collectors.toList());
Optional<List<String>> o = optional.map(function);
System.out.println(o.get());
11、flatMap（Function）
/*
* 如果存在 value 则返回 value 并作为 mapper 的输入将其输出作为新的 value 存放至 Optional 否则返回一个 null 的 Optional
* 如果经过 mapper 后得到的结果为 null 返回一个 null 的 Optional
* mapper 函数若为 null 则抛出 NullPointerException
*
* 与 map 的方法的区别：
* map
*
* return Optional.ofNullable(mapper.apply(value));
*
* flatMap
*
* Optional r = (Optional) mapper.apply(value);
* return Objects.requireNonNull(r);
* flatMap：对集合中每个元素进行操作然后再扁平化
*
*
* public Optional flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
* Objects.requireNonNull(mapper);
* if (!isPresent()) {
* return empty();
* } else {
* @SuppressWarnings(“unchecked”)
* Optional r = (Optional) mapper.apply(value);
* return Objects.requireNonNull(r);
* }
* }
*/
System.out.println(“—————————————\n”);
Function<List<String>, Optional<List<String>>> func =
up -> Optional.of(up.stream().map(String::toUpperCase).collect(Collectors.toList()));
Optional<List<String>> u = optional.flatMap(func);
System.out.println(u.get());

}

}
六、测试
. ____ _ __ _ _
/\\ / ___’_ __ _ _(_)_ __ __ _ \ \ \ \
(()\___ | ‘_ | ‘_| | ‘_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| |) ) ) )
‘ |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.1.2.RELEASE)

2019-02-01 18:29:34.870 INFO 17140 — [main] com.java.design.java8.OptionalTest : Starting OptionalTest on DESKTOP-87RMBG4 with PID 17140 (started by 46250 in E:\IdeaProjects\design)
2019-02-01 18:29:34.871 INFO 17140 — [main] com.java.design.java8.OptionalTest : No active profile set, falling back to default profiles: default
2019-02-01 18:29:35.437 INFO 17140 — [main] com.java.design.java8.OptionalTest : Started OptionalTest in 0.775 seconds (JVM running for 1.574)
—————————————

optional 容器中存在的值:[Kirito, Love, Asuna]
—————————————

optional 容器中存在值：true
empty 容器中存在值:false
—————————————

optional 容器中不存在值：false
empty 容器中不存在值：true
—————————————

optional 容器中存在值就进行 Consumer 消费（打印输出）
[Kirito, Love, Asuna]
—————————————

容器中存在值就打印值，不存在打印 hello world
[Kirito, Love, Asuna]
hello world
—————————————

遍历集合元素
Kirito
Love
Asuna
—————————————

Optional[[Optional, or, supplier]]
—————————————

以 stream 流遍历 optional 容器内的值
[Kirito, Love, Asuna]
—————————————

容器中存在值就返回值不存在就返回 {“hello”,”world”}
[hello, world]
—————————————

[do, orElseGet]
—————————————

容器中存在值就返回值不存在就返回 NoSuchElementException
[Kirito, Love, Asuna]
NoSuchElementException —> No value present
—————————————

Supplier NoSuchElementException —> No value present
—————————————

[KIRITO, LOVE, ASUNA]
—————————————

[KIRITO, LOVE, ASUNA]

Process finished with exit code 0

正文完

发表至： java

2019-02-01

0

关于java:GitHub标星30K的Java面试八股文长啥样

关于java:集合案例

关于java:最简-Spring-AOP-源码分析

XML解析

解锁Spring框架姿势1

深入理解 lambda表达式 与 Optional Null 源码解析（Java11 三）

站内搜索

深入理解 lambda表达式与 Optional Null 源码解析（Java11 三）