Java8是Oracle公司在2014年3月发布的版本，是Java5之后最重要的版本，带了了诸多方面的新特性，包括语言、类库、编译器及JVM等新特性。本文重点介绍Java8中语法相关的新特性，主要包括Lambda表达式、Stream API、New Date API、Optional等。

Lambda表达式

什么是Lambda

Lambda expression is a new feature which is introduced in Java 8. A lambda expression is an anonymous function. A function that doesn’t have a name and doesn’t belong to any class. The concept of lambda expression was first introduced in LISP programming language.

Lambda这个概念最早起源于LISP语言，Java8中引入了这个特性，Lambda表达式其实是一个匿名函数，这个函数没有名称并且不属于任何类。

为什么需要Lambda

在Java8之前的版本中，如果我们需要实现行为参数化，必须要将特定的行为包装在某个类中，然后将对象传递给具体方法进行执行。匿名内部类的实现如下：

ExecutorService executorService = Executors.newFixedThreadPool(2);
executorService.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("查询材料库存数！");
    }
});
executorService.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("查询材料门店销量！");
    }
});

这种方式写出的代码十分冗长，实际我们想要执行的其实就是run方法中的功能，Java8提供了Lambda表达式来解决这个问题，经过Lambda表达式改造的代码清晰简洁：

ExecutorService executorService = Executors.newFixedThreadPool(2);
executorService.execute(() -> System.out.println("查询材料库存数！"));
executorService.execute(() -> System.out.println("查询材料门店销量！"));

如何使用Lambda

Lambda表达式由参数、箭头和主体组成。Lambda的基本语法如下，有两种基本形式：

// 单行语句
(parameters) -> expression
executorService.execute(() -> System.out.println("查询材料库存数！"));
// 多行语句
(parameters) -> { statements; }
executorService.execute(() -> {
    System.out.println("查询材料门店销量！");
    System.out.println("查询材料门店销量！");
});

• 参数列表：函数式接口中的抽象方法对应的参数列表，前文例子中函数式接口为Runnable接口，抽象方法为run方法，为空参数方法；
• 箭头：Lambda表达式的标志符号，用来分隔参数列表和Lambda主体；
• Lambda主体：功能代码块，多行需要使用花括号{}；

那么究竟在哪里可以使用Lambda表达式——在函数式接口上使用Lambda表达式，前文示例中的Runnable接口就是一个函数式接口。

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

函数式接口

那么什么是函数式接口呢？简单来说，就是只定义了一个抽象方法的接口。Lambda表达式允许直接以内联的方式为函数式接口的抽象方法提供实现，并把整个表达式作为函数式接口的实例。
在Java8中，提供了@FunctionalInterface注解来专门表示函数式接口，该注解不是必须的，但是添加了该注解编译器会进行语法检查，保证接口中只能包含一个抽象方法。

观察下如下接口是否符合函数式接口的定义？

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}
@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }
    ...
    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        return Collections.reverseOrder();
    }
    ...
}

为什么Comparator接口也是函数式接口？可以参考FunctionalInterface注解的javadoc：

If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface’s abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere. Note that instances of functional interfaces can be created with lambda expressions, method references, or constructor references.

如果一个接口中定义了一个抽象方法——重写Object基类中的公有方法，那么这个抽象方法不会被算入接口抽象方法的计数中，因为任何一个这个接口的实现类本来就会通过继承Object基类来实现该方法。

Java8新增了java.util.function包，在function包中引入了一些常用的函数式接口：

• Predicate：断言型接口，抽象方法为boolean test(T t)，传入一个参数，返回一个布尔值。

// 断言型接口
Predicate<Integer> predicate = t -> t.equals(30);
System.out.println(predicate.test(35));
// 断言型接口原始类型特化
IntPredicate intPredicate = t -> t > 30;
System.out.println(intPredicate.test(25));

• Consumer：消费型接口，抽象方法为void accept(T t)，传入一个参数，没有返回值。

// 消费型接口
// Consumer<String> consumer = t -> System.out.println(t);
Consumer<String> consumer = System.out::println;
consumer.accept("张三");

• Function：函数型接口，抽象方法为R apply(T t)，传入一个参数，返回另一个值。

// 函数型接口
// Function<Integer, String> function = (t) -> String.valueOf(t);
Function<Integer, String> function = String::valueOf;
System.out.println(function.apply(2020));

• Supplier：供给型接口，抽象方法为T get()，不传入参数，返回一个结果。

// 生产型接口
Supplier<String> supplier = () -> "2020年世界和平！";
System.out.println(supplier.get());

• UnaryOperator：一元操作型接口，继承自Function接口，传入一个参数，返回该参数。

// 一元操作型接口
// UnaryOperator<String> unaryOperator = t -> t.toUpperCase();
UnaryOperator<Integer> unaryOperator = t -> t + 1;
System.out.println(unaryOperator.apply(99));

方法引用&构造方法引用

方法引用是特殊场景下Lambda表达式的一种简洁写法。如果某个方法刚好满足了Lambda表达式的形式，那么就可以用方法引用来表示Lambda表达式。
方法引用&构造方法引用有四类：

• 类名::静态方法名——在lambda表达式中，调用了某个类的静态方法；
• 对象::实例方法名——在lambda表达式中，调用了某个外部对象的实例方法；
• 类名::实例方法名——在lambda表达式中，调用了lambda参数列表中的对象实例方法；
• 类名::new——在lambda表达式中，调用了构造方法创建对象；

List<String> nums = Lists.newArrayList("-11", "111", "23", "14", "6", "18");
// 类名::静态方法名，在lambda表达式中，调用了某个类的静态方法
// nums.sort(Comparator.comparing(num -> Integer.valueOf(num)));
nums.sort(Comparator.comparing(Integer::valueOf));
System.out.println("--类名::静态方法名--" + nums);
// 对象::实例方法名，在lambda表达式中，调用了某个外部对象的实例方法
// Supplier<Integer> supplier = () -> nums.size();
Supplier<Integer> supplier = nums::size;
System.out.println(supplier.get());
// 类名::实例方法名，在lambda表达式中，调用了lambda参数列表中的对象实例方法
// nums.sort(Comparator.comparing(num -> num.length()));
nums.sort(Comparator.comparing(String::length));
System.out.println("--类名::实例方法名--" + nums);
// 类名::new，在lambda表达式中，调用了构造方法创建对象
/*
Function<String, BigInteger> function = new Function<String, BigInteger>() {
    @Override
    public BigInteger apply(String s) {
        return new BigInteger(s);
    }
};
*/
Function<String, BigInteger> function = BigInteger::new;
System.out.println(function.apply("12345678901234567890"));

Stream API

什么是Stream

Stream API是对集合功能的增强，借助于Lambda表达式，能够极大地提高编程效率和程序可读性。Stream处理集合数据时，将要处理的元素看做一种流，流在管道中传输，并且可以在管道的节点上处理，包括筛选、去重、排序、聚合等。元素流在管道中经过中间操作的处理，最后由结束操作得到处理结果。

使用Stream API具有以下优势：

• 提升性能——Stream会记录下过程操作、并对这些操作进行叠加，最后在一个迭代循环中执行所有叠加的操作，减少迭代次数；
• 代码简洁——函数式编程风格的代码简洁、意图明确；
• 多核友好——只需调用parallel()方法，即可实现并行程序，简化编码；

使用Stram API前的编码风格：

List<Staff> staffs = Lists.newArrayList(Staff.builder().name("james").age(35).build(), Staff.builder().name("wade").age(37).build(),
        Staff.builder().name("kobe").age(41).build(), Staff.builder().name("rose").age(31).build());
List<Staff> results = Lists.newArrayList();
// 筛选出年龄大于35岁的员工
for (Staff staff : staffs) {
    if (staff.getAge() <= 35) {
        continue;
    }
    results.add(staff);
}
System.out.println(results);

使用Stram API后的编码风格：

List<Staff> staffs = Lists.newArrayList(Staff.builder().name("james").age(35).build(), Staff.builder().name("wade").age(37).build(),
        Staff.builder().name("kobe").age(41).build(), Staff.builder().name("rose").age(31).build());
// 使用Stream API进行筛选
List<Staff> streamResults = staffs.stream().filter(staff -> staff.getAge() > 35).collect(Collectors.toList());
System.out.println(streamResults);

如何创建Stream

通常创建Stream都是调用集合（Collection）类中的stream()方法或者parallelStream()方法，可以对应生成串行流和并行流。

// 从List创建Stream
Lists.newArrayList(123, 11, 323, 2).stream().map(num -> num * 2).forEach(System.out::println);
// 直接从Stream创建
Stream.of(123, 11, 323, 2).map(num -> num * 2).forEach(System.out::println);

也可以使用IntStream、LongStream、DoubleStream从基本类型创建Stream，基本类型创建的Stream支持一些特殊的结束操作——sum()、average()、max()。

// 通过IntStream直接创建
System.out.println(IntStream.of(123, 11, 323, 2).max().orElse(-1));

Stream和IntStream、LongStream、DoubleStream之间可以相互装换：

// 从Stream转换成IntStream
Stream.of("123", "11", "323", "2").mapToInt(Integer::parseInt).average().ifPresent(System.out::println);
// 从IntStream转换成Stream
IntStream.of(123, 11, 323, 2).mapToObj(num -> "f6" + num).forEach(System.out::println);

常用Stream操作

Stream操作具有如下特点：

• Stream操作不会修改原始的数据；
• 操作无状态，不依赖外部变量，在Stream操作内部引用外部非final变量会报错（外部变量默认final，修改之后会报错）；
• Stream中记录中间操作，并对这些操作进行叠加，最后在一个迭代循环中执行所有叠加的操作，生成结果；

根据Stream操作的执行阶段，可以分为两类：

• 中间操作：总是会惰式执行，调用中间操作只会生成一个标记了该操作的新Stream，中间操作的结果仍然是Stream，可以继续使用Stream API连续调用。中间操作又可以分为有状态操作和无状态操作，有状态操作是指该操作只有拿到所有元素之后才能继续执行，而无状态操作则不受之前元素的影响；
• 结束操作：会触发实际计算，计算发生时会把所有中间操作以pipeline的方式执行，这样可以减少迭代次数。结束操作的结果通常是一个非Stream结果，计算完成之后Stream就会失效（只能遍历一次）；

常用的Stream操作如下图：

常用的中间操作

• filter——根据Predicate条件，过滤出符合条件的元素：

// Stream<T> filter(Predicate<? super T> predicate)
// 过滤绝对值开根号大于15的数字
Lists.newArrayList(112, 131, 323, 234, 730, 177, -226, 434)
        .stream().filter(num -> Math.sqrt(Math.abs(num)) > 15).forEach(System.out::println);

• sorted——对集合中的元素进行排序：

// Stream<T> sorted(Comparator<? super T> comparator)
// 字符串装换成数字排序
List<String> nums = Lists.newArrayList("112", "131", "323", "234", "730", "177", "-226", "434");
nums.stream().sorted(Comparator.comparingInt(Integer::parseInt)).forEach(System.out::println);

• map——对集合中的每个元素按照mapper操作进行转换，转换前后Stream中元素的个数不会改变，但元素的类型取决于转换之后的类型：

// Stream<R> map(Function<? super T,? extends R> mapper)
// map操作：对集合中的每个元素按照mapper操作进行转换
Lists.newArrayList("a1", "a2", "a3", "a4", "a5").stream().map(String::toUpperCase).forEach(System.out::println);

• flatMap——map方法只能把一个对象转换成另一个对象，如果需要将一个对象转换成多个，需要使用flatMap：

// Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
// flatMap操作：找出所有员工的兴趣爱好
List<Staff> staffs = Lists.newArrayList(Staff.builder().name("张三").age(18).hobbies(Lists.newArrayList("篮球", "足球", "围棋")).build(),
        Staff.builder().name("李四").age(27).hobbies(Lists.newArrayList("书法", "围棋", "乒乓球")).build(),
        Staff.builder().name("王五").age(33).hobbies(Lists.newArrayList("品茶", "读书", "篮球")).build());
Set<String> hobbies = staffs.stream().map(Staff::getHobbies).flatMap(Collection::stream).collect(Collectors.toSet());
System.out.println(hobbies);

常用的结束操作

• forEach——对每一个元素的执行指定的action操作：

// void forEach(Consumer<? super T> action)
// forEach操作：对每一个元素的执行指定的action操作
Lists.newArrayList(112, 131, 323, 234, 730, 177, -226, 434).forEach(System.out::println);

• collect——collect方法接收一个Collector参数，Collector可以将Stream转换成集合，如List、Set或Map。JDK内置了很多常用的Collector，大多数场景下不需要自己实现：

// <R, A> R collect(Collector<? super T, A, R> collector);
// collect操作：将Stream转换成集合，如：List、Set、Map
// Map<String, Staff> staffMap = staffs.stream().collect(Collectors.toMap((Staff::getName), Function.identity()));
Map<String, Staff> staffMap = staffs.stream().collect(Collectors.toMap((Staff::getName), Function.identity(), (oldValue, newValue) -> newValue));
System.out.println(staffMap);

将Stream元素转换成map的时候，需要特别注意：key必须是唯一的，否则会抛出IllegalStateException 。如果想主动规避这个问题，需要我们传入一个merge function，来指定重复的元素映射的方式。也可以使用Collectors.groupingBy()，按照指定key分组的方式来代替：

// collect操作：按照指定key分组
Map<String, List<Staff>> staffsMap = staffs.stream().collect(Collectors.groupingBy((Staff::getName)));
System.out.println(staffsMap);

• reduce——reduce操作可以实现从一组元素中生成一个值，sum()、max()、min()、count()等都是reduce操作，将他们单独设为函数方便日常使用。redeue方法定义了三种重载形式：

第一种方法声明为：Optional reduce(BinaryOperator accumulator); 参数为累加器，返回值为Optional对象，通过accumulator计算得到一个最终结果，通过Optional对象中返回：

// 实现#号拼接字符串
// 第一次执行时第一个参数是Stream中的第一个元素，第二个参数是Stream参数中的第二个元素
// 后面每次执行的中间结果赋给第一个参数，然后第二个参数为Stream中的下一个元素，依次执行，最后返回一个Optional
Lists.newArrayList("d4", "c3", "a1", "b2", "f5").stream().sorted().reduce((s1, s2) -> {
    System.out.println("s1:" + s1);
    System.out.println("s2:" + s2);
    System.out.println("--------");
    return s1 + "#" + s2;
}).ifPresent(System.out::println);
// 执行结果
s1:a1
s2:b2
--------
s1:a1#b2
s2:c3
--------
s1:a1#b2#c3
s2:d4
--------
s1:a1#b2#c3#d4
s2:f5
--------
a1#b2#c3#d4#f5

第二种方法声明为：T reduce(T identity, BinaryOperator accumulator); 新增了一个初始化类型。

// 第一次执行时第一个参数是指定的初始对象，第二个参数是Stream参数中的第一个元素
// 后面每次执行的中间结果赋给第一个参数，然后第二个参数为Stream中的下一个元素，依次执行，最后返回一个和初始值类型相同的结果
System.out.println(Stream.of(1, 2, 3, 4, 5).reduce(10, (p1, p2) -> {
    System.out.println("p1:" + p1);
    System.out.println("p2:" + p2);
    System.out.println("--------");
    return p1 + p2;
}));
// 执行结果
p1:10
p2:1
--------
p1:11
p2:2
--------
p1:13
p2:3
--------
p1:16
p2:4
--------
p1:20
p2:5
--------
25

第三种方法声明为： U reduce(U identity, BiFunction accumulator, BinaryOperator combiner); 在初始对象和累加器基础上，添加了组合器combiner。

// 第三种方式，求单词长度之和，使用串行流和并行流分别执行
System.out.println(Stream.of("d4", "c3", "a1", "b2", "f5").reduce(0, (o1, o2) -> {
    String threadName = Thread.currentThread().getName();
    System.out.println("BiFunction--" + threadName);
    System.out.println("o1:" + o1 + "--" + threadName);
    System.out.println("o2:" + o2 + "--" + threadName);
    return o1 + o2.length();
}, (o1, o2) -> {
    String threadName = Thread.currentThread().getName();
    System.out.println("BinaryOperator--" + threadName);
    System.out.println("o1:" + o1 + "--" + threadName);
    System.out.println("o2:" + o2 + "--" + threadName);
    return o1 + o2;
}));
// 执行结果
BiFunction--main
o1:0--main
o2:d4--main
BiFunction--main
o1:2--main
o2:c3--main
BiFunction--main
o1:4--main
o2:a1--main
BiFunction--main
o1:6--main
o2:b2--main
BiFunction--main
o1:8--main
o2:f5--main
10

BiFunction--main
o1:0--main
o2:a1--main
BiFunction--ForkJoinPool.commonPool-worker-3
o1:0--ForkJoinPool.commonPool-worker-3
o2:d4--ForkJoinPool.commonPool-worker-3
BiFunction--ForkJoinPool.commonPool-worker-2
o1:0--ForkJoinPool.commonPool-worker-2
o2:f5--ForkJoinPool.commonPool-worker-2
BiFunction--ForkJoinPool.commonPool-worker-3
o1:0--ForkJoinPool.commonPool-worker-3
o2:b2--ForkJoinPool.commonPool-worker-3
BinaryOperator--ForkJoinPool.commonPool-worker-3
o1:2--ForkJoinPool.commonPool-worker-3
o2:2--ForkJoinPool.commonPool-worker-3
BinaryOperator--ForkJoinPool.commonPool-worker-3
o1:2--ForkJoinPool.commonPool-worker-3
o2:4--ForkJoinPool.commonPool-worker-3
BiFunction--ForkJoinPool.commonPool-worker-1
o1:0--ForkJoinPool.commonPool-worker-1
o2:c3--ForkJoinPool.commonPool-worker-1
BinaryOperator--ForkJoinPool.commonPool-worker-1
o1:2--ForkJoinPool.commonPool-worker-1
o2:2--ForkJoinPool.commonPool-worker-1
BinaryOperator--ForkJoinPool.commonPool-worker-1
o1:4--ForkJoinPool.commonPool-worker-1
o2:6--ForkJoinPool.commonPool-worker-1
10

// match操作：用来判断某一种规则是否与流对象匹配
boolean anyMatch = staffs.stream().anyMatch((staff) -> staff.getName().startsWith("张"));
System.out.println(anyMatch);
boolean allMatch = staffs.stream().allMatch((staff) -> staff.getAge().equals(34));
System.out.println(allMatch);
boolean noneMatch = staffs.stream().noneMatch((staff) -> staff.getAge().equals(34));
System.out.println(noneMatch);

// 初始化日期
LocalDate localDate = LocalDate.of(2020, 1, 10);
// 年份 2020
System.out.println(localDate.getYear());
// 年份中第几天 10
System.out.println(localDate.getDayOfYear());
// 月份 JANUARY
Month month = localDate.getMonth();
System.out.println(month);
// 月份中的第几天 10
System.out.println(localDate.getDayOfMonth());
// 一周的第几天：FRIDAY
System.out.println(localDate.getDayOfWeek());
// 月份的天数 31
System.out.println(localDate.lengthOfMonth());
// 是否为闰年 true
System.out.println(localDate.isLeapYear());

// 初始化一个时间：17:50:40
LocalTime localTime = LocalTime.of(17, 50, 40);
// 时：17
System.out.println(localTime.getHour());
// 分：50
System.out.println(localTime.getMinute());
// 秒：40
System.out.println(localTime.getSecond());

LocalDateTime localDateTime = LocalDateTime.of(2020, Month.JANUARY, 10, 17, 50, 40);
LocalDate localDate = LocalDate.of(2020, Month.JANUARY, 10);
LocalTime localTime = LocalTime.of(17, 50, 40);
LocalDateTime combineLocalDateTime = localDate.atTime(localTime);
// LocalDateTime combineLocalDateTime = localTime.atDate(localDate);
// 从LocalDateTime中获取年月日时分秒
System.out.println(combineLocalDateTime.getYear());
System.out.println(combineLocalDateTime.getMonth());
System.out.println(combineLocalDateTime.getDayOfMonth());
System.out.println(combineLocalDateTime.getHour());
System.out.println(combineLocalDateTime.getMinute());
System.out.println(combineLocalDateTime.getSecond());
// LocalDateTime转化成LocalDate或LocalTime
LocalDate transferLocalDate = localDateTime.toLocalDate();
LocalTime transferLocalTime = localDateTime.toLocalTime();

// Instant可以使用now()方法创建，也可以通过ofEpochSecond方法创建
Instant now = Instant.now();
// 2020-01-12T16:16:41.723Z
System.out.println(now);
// ofEpochSecond方法第一个参数表示从1970-01-01 00:00:00开始到现在的秒数
// ofEpochSecond方法第二个参数表示纳秒数，0~999,999,999
Instant instant = Instant.ofEpochSecond(9999, 1000);
// 1970-01-01T02:46:39.000001Z
System.out.println(instant);

// 使用of创建Duration，统一一个单位设置
Duration duration1 = Duration.of(7, ChronoUnit.DAYS);
Duration duration2 = Duration.of(3000, ChronoUnit.SECONDS);
// 2018-07-03 09:00:00
LocalDateTime start = LocalDateTime.of(2018, Month.JULY, 3, 9, 0, 0);
// 2020-01-13 18:00:00
LocalDateTime end = LocalDateTime.of(2020, Month.JANUARY, 13, 18, 0, 0);
Duration duration = Duration.between(start, end);
// 总天数
System.out.println(duration.toDays());
// 总小时数
System.out.println(duration.toHours());
// 总分钟数
System.out.println(duration.toMinutes());
// 总秒数
System.out.println(duration.getSeconds());

// 创建2年3个月6天的范围，年月日单独字段设置
Period period1 = Period.of(2, 3, 6);
// 从2018-07-03到2020-01-13
Period period2 = Period.between(LocalDate.of(2018, 7, 3), LocalDate.of(2020, 1, 13));
System.out.println(period2.getYears());
System.out.println(period2.getMonths());
System.out.println(period2.getDays());

// 2019-12-01
LocalDate date = LocalDate.of(2019, 12, 1);
// 修改日期为2020-01-13 2020-01-13
LocalDate newDate = date.withYear(2020).withMonth(1).withDayOfMonth(13);
System.out.println(newDate);
// 增加一年，减一个月，加十天 2020-12-23
LocalDate localDate = newDate.plusYears(1).minusMonths(1).plus(10, ChronoUnit.DAYS);
System.out.println(localDate);
// 查找本月最后一个周五 2020-01-31
System.out.println(LocalDate.now().with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY)));

// 20200113
System.out.println(LocalDateTime.now().format(DateTimeFormatter.BASIC_ISO_DATE));
// 2020-01-13
System.out.println(LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE));
// 11:02:38.148
System.out.println(LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME));
// 2020-01-13
System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));

// 使用of为非null值创建Optional，ofNullable
String name = "张三";
Integer age = LocalDate.now().isAfter(LocalDate.of(2020, 1, 10)) ? null : 0;
Optional<String> nameOptional = Optional.of(name);
Optional<Integer> ageOptional = Optional.ofNullable(age);

// 使用isPresent判断Optional是否存在值
System.out.println(nameOptional.isPresent());
System.out.println(ageOptional.isPresent());

// nameOptional.ifPresent(value -> System.out.println(value));
nameOptional.ifPresent(System.out::println);
ageOptional.ifPresent(System.out::println);
// 执行结果
// 张三

System.out.println(nameOptional.get());
// NoSuchElementException: No value present
// System.out.println(ageOptional.get());

// orElse设置为空时的默认值
System.out.println(nameOptional.orElse("李四"));
System.out.println(ageOptional.orElse(20));
// orElseGet设置为空时的默认值
System.out.println(ageOptional.orElseGet(() -> 20));
// orElseThrow设置为空时抛出的异常
System.out.println(ageOptional.orElseThrow(RuntimeException::new));

// 使用map、flatMap映射得到Optional
nameOptional.map(value -> value.replace("三", "四")).ifPresent(System.out::println);
nameOptional.flatMap(value -> Optional.of(value.replace("三", "四"))).ifPresent(System.out::println);

// 使用filter对原始值进行过滤
System.out.println(nameOptional.filter(value -> value.length() > 2).isPresent());

/**
 * 根据名称过滤员工
 *
 * @param staffs
 * @param name
 * @param age
 * @return
 */
public static List<Staff> filterStaffByNameAndAge(List<Staff> staffs, String name, Optional<Integer> age) {
    return staffs.stream()
            .filter(p -> p.getName().equals(name))
            .filter(p -> p.getAge() >= age.orElse(0))
            .collect(Collectors.toList());
}
// 使用Optional的注意事项——不要作为方法参数传递
List<Staff> staffs = Lists.newArrayList(Staff.builder().name("张三").age(18).build(),
        Staff.builder().name("李四").age(27).hobbies(Lists.newArrayList("书法", "围棋", "乒乓球")).build(),
        Staff.builder().name("王五").age(35).hobbies(Lists.newArrayList("读书", "篮球", "爬山")).build());
filterStaffByNameAndAge(staffs, "李四", null);

// 使用Optional的注意事项——不要作为类中的字段，不支持序列化
Staff staff = Staff.builder().name("张三").telephoneNumber(Optional.of("12345678900")).build();
try {
    // java.io.NotSerializableException: java.util.Optional
    ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("object.txt"));
    outputStream.writeObject(staff);
} catch (Exception e) {
    System.out.println(e.toString());
}