Java笔记之Java8新特性

本笔记来自 计算机程序的思维逻辑 系列文章

Lambda表达式

Lambda表达式

语法

匿名函数，由 -> 分隔为两部分

• 前面是方法的参数

  参数只有1个时，不需要加 ()

  参数超过1个时，需要加 ()

  参数为空时，需要加 ()

  参数类型声明可以省略

• 后面 {} 内是方法的代码

  只有一个语句时，{} 和 return 可以省略，该代码是一个表达式，其值就是函数返回值，结尾不能加 ;

变量引用

与匿名内部类类似，Lambda表达式也可以访问定义在主体代码外部的变量，但对于局部变量，它也只能访问final类型的变量，与匿名内部类的区别是，它不要求变量声明为final，但变量事实上不能被重新赋值

对比

Java会为每个匿名内部类生成一个类，但Lambda表达式不会

函数式接口

函数式接口也是接口，但只能有一个抽象方法，使用@FunctionalInterface注解声明

Lambda表达式可以赋值给函数式接口

预定义的函数式接口

• Predicate 谓词，测试输入是否满足条件

  boolean test(T t)

• Function 函数转换，输入类型 T ，输出类型 R

  R apply(T t)

• Consumer 消费者

  void accept(T t)

• Supplier 工厂方法

  T get()

• UnaryOperator 函数转换，输入和输出类型一样

  T apply(T t)

• BiFunction 函数转换，接受两个参数 T 和 U ，输出 R

  R apply(T t, U u)

• BinaryOperator 函数转换，输入和输出类型一样

  T apply(T t1, T t2)

• BiConsumer 消费者，接受两个参数

  void accept(T t, U u)

• BiPredicate 谓词，接受两个参数

  boolean test(T t, U u)

方法引用

Lambda表达式的一种简写方法，由 :: 分隔为两部分，前面是类名或变量名，后面是方法名

方法可以是静态方法，也可以是实例方法

函数的复合

函数式接口和Lambda表达式还可作方法的返回值，传递代码回调用者，构造复合的函数

接口的静态方法和默认方法

在Java8之前，接口中的方法都是抽象方法，没有实现体

在Java8允许在接口中定义两类新方法：静态方法 和 默认方法

引入默认方法主要是函数式数据处理的需求，为了便于给接口增加功能

函数式数据处理

Stream

Java8引入一套新的类库，位于包java.util.stream下，称之为Stream API

该接口类似一个迭代器，提供了丰富的操作

特点

• 没有显式的循环迭代，循环过程被Stream的方法隐藏
• 提供给了声明式的处理函数
• 流畅式接口，方法调用链接在一起，清晰易读

方法

• Stream filter(Predicate predicate) 过滤

  无状态的中间操作

• Stream map(Function mapper) 转换

  无状态的中间操作

• Stream distinct() 去重

  有状态的中间操作

• Stream sorted() 排序

  有状态的中间操作

• Stream limit(long maxSize) 限制个数

  有状态的中间操作；达到 maxSize 后就提前结束操作

• Stream skip(long n) 跳过

  有状态的中间操作

• Stream peek(Consumer action) 获取元素，额外处理

  无状态的中间操作；主要用于调试，观察元素变化

• Stream flatMap(Function> mapper) 1 到 n 的映射

• R collect(Collector collector) 输出

  终端操作

• Optional min(Comparator comparator) 返回最小值

  终端操作

• Optional max(Comparator comparator) 返回最大值

  终端操作

• boolean anyMatch(Predicate predicate) 是否有一元素满足条件

  终端操作

• boolean allMatch(Predicate predicate) 所有元素是否都满足条件

  终端操作

• boolean noneMatch(Predicate predicate) 所有元素是否都不满足条件

  终端操作

• Optional findFirst() 返回第一个元素

  终端操作；如果流为空，则返回 Optional.empty()

• Optional findAny() 返回任一元素

  终端操作；如果流为空，则返回 Optional.empty()

• Optional reduce(BinaryOperator accumulator) 归约，折叠

  终端操作；将流中的元素归约为一个值

构建流

Collection

Java8给Collection接口增加了两个默认方法，使其返回Stream

• default Stream stream() 返回一个顺序流

  由一个线程执行操作

• default Stream parallelStream() 返回一个并行流

  可能由多个线程并行执行

Arrays

Java8新增几个方法，返回Stream

• Stream stream(T[] array)
• Stream stream(T[] array, int startInclusive, int endExclusive)

Stream

• static Stream empty() 返回空流

• static Stream of(T t) 返回只包含一个元素的流

• static Stream of(T... values) 返回包含多个元素的流

• static Stream generate(Supplier s) 通过 Supplier 生成流

  流的个数是无限的

• static Stream iterate(final T seed, final UnaryOperator f) 迭代生成流

  流的个数是无限的

Collector

定义

public interface Collector {
    Supplier supplier();
    BiConsumer accumulator();
    BinaryOperator combiner();
    Function finisher();
    Set characteristics();
}

实现原理

通过调用该接口的方法，组合成最终需要的结果

• 调用supplier的get方法获得 A
• 遍历 T ，调用accumulator的accept方法，参数为 A 和 当前元素 t ，返回 A
• 最后调用finisher的apply方法，转换为 R 返回

Collectors

容器收集器

• > Collector toCollection(Supplier collectionFactory) 通用，接受一个工厂方法作参数

• Collector> toList()

• Collector> toSet()

• Collector> toMap(Function keyMapper, Function valueMapper)

  两个参数，一个将元素转换为 键 ，另一个将元素转换为 值

字符串收集器

• Collector joining() 连接字符串
• Collector joining(CharSequence delimiter) 连接字符串，并加分隔符
• Collector joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 连接字符串，加分隔符，前缀和后缀

分组

• Collector>> groupingBy(Function classifier)
• Collector> groupingBy(Function classifier, Collector downstream)
• > Collector groupingBy(Function classifier, Supplier mapFactory, Collector downstream)

组合式异步编程

可以方便地将多个有一定依赖关系的异步任务以流水线的方式组合在一起

简洁自然地表达多个异步任务之间的依赖关系和执行流程

CompletionStage

表示任务的阶段，多个CompletionStage可以以流水线的方式组合起来

其提供了大量方法，可以方便地响应任务事件，构建任务流水线，实现组合式异步编程

CompletableFuture

实现了Future和CompletionStage接口

定义

接受 Supplier 或 Runnable ，不接受 Callable

• CompletableFuture supplyAsync(Supplier supplier)
• CompletableFuture supplyAsync(Supplier supplier, Executor executor)
• CompletableFuture runAsync(Runnable runnable)
• CompletableFuture runAsync(Runnable runnable, Executor executor)
• CompletableFuture completedFuture(U value)

新特性

• T join() 等待任务结束，返回结果

  但不会抛出受检异常，如果异常结束，则包装成CompletionException抛出

• T getNow(T valueIfAbsent) 如果任务还没结束，返回 valueIfAbsent

• boolean isCompletedExceptionally() 判断任务是否异常结束

• boolean complete(T value) 显式设置任务成功及结果

• boolean completeExceptionally(Throwable ex) 显式设置任务异常结束

响应结果和异常

• CompletableFuture whenComplete(BiConsumer action)

  当任务完成（正常完成和异常结束）时，执行该 action ，不改变任务结果

• CompletableFuture whenCompleteAsync(BiConsumer action)

  当任务完成（正常完成和异常结束）时，异步执行该 action ，不改变任务结果

• CompletableFuture handle(BiFunction fn)

  当任务完成（正常完成和异常结束）时，执行该 fn ，改变任务结果

• CompletableFuture handleAsync(BiFunction fn)

  当任务完成（正常完成和异常结束）时，异步执行该 fn ，改变任务结果

• CompletableFuture exceptionally(Function fn)

  当任务发生异常时，执行该 fn ，改变任务结果

构建依赖的任务流

依赖单一阶段的任务流

• CompletableFuture thenRun(Runnable action) 声明下一个任务

  只有在前一个阶段没有异常结束，下一个阶段的任务才会执行

  如果前一个阶段发生了异常，所有后续阶段都不会运行，结果会被设为相同的异常

  指定的任务不需要前一个阶段的任务结果作为参数，也没有返回值

• CompletableFuture thenAccept(Consumer action)

  接受前一个任务的结果作为参数，执行 action

• CompletableFuture thenApply(Function fn)

  接受前一个任务的结果作为参数，执行 fn 返回一个新的任务结果

• CompletableFuture thenCompose(Function> fn)

  接受前一个任务的结果作为参数，返回一个任务阶段

依赖两个阶段的任务流

• CompletableFuture runAfterBoth(CompletionStage other, Runnable action)

  在当前任务和 other 执行完成后，执行 action

• CompletableFuture thenAcceptBoth(CompletionStage other, BiConsumer action)

  接受当前任务和 other 的结果，执行 action

• CompletableFuture thenCombine(CompletionStage other, BiFunction fn)

  接受当前任务和 other 的结果，执行 fn 返回新的任务结果

• CompletableFuture runAfterEither(CompletionStage other, Runnable action)

  两个任务任一完成后，则执行 action

• CompletableFuture acceptEither(CompletionStage other, Consumer action)

  两个任务任一完成后，接受其结果，执行 action

• CompletableFuture applyToEither(CompletionStage other, Function fn)

  两个任务任一完成后，接受其结果，执行 action ，返回新的任务结果

依赖多个阶段的任务流

• CompletableFuture allOf(CompletableFuture... cfs)

  基于多个CompletableFuture构建一个新的任务

  所有任务完成后，当前任务才完成

  如果有任务异常结束，则任务结果也是异常；但不会因异常而提前结束，而是等待所有阶段结束，如果有多个异常结束，任务保存最后一个异常

• CompletableFuture