Java笔记之Java8新特性

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

Lambda表达式

Lambda表达式

语法

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

• 前面是方法的参数

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

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

  参数为空时，需要加 ()

  参数类型声明可以省略

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

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

变量引用

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

对比

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

函数式接口

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

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

预定义的函数式接口

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

  boolean test(T t)

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

  R apply(T t)

• Consumer<T> 消费者

  void accept(T t)

• Supplier<T> 工厂方法

  T get()

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

  T apply(T t)

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

  R apply(T t, U u)

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

  T apply(T t1, T t2)

• BiConsumer<T, U> 消费者，接受两个参数

  void accept(T t, U u)

• BiPredicate<T, U> 谓词，接受两个参数

  boolean test(T t, U u)

方法引用

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

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

函数的复合

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

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

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

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

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

函数式数据处理

Stream

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

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

特点

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

方法

• Stream<T> filter(Predicate<? super T> predicate) 过滤

  无状态的中间操作

• <R> Stream<R> map(Function<? super T, ? extends R> mapper) 转换

  无状态的中间操作

• Stream<T> distinct() 去重

  有状态的中间操作

• Stream<T> sorted() 排序

  有状态的中间操作

• Stream<T> limit(long maxSize) 限制个数

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

• Stream<T> skip(long n) 跳过

  有状态的中间操作

• Stream<T> peek(Consumer<? super T> action) 获取元素，额外处理

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

• <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) 1 到 n 的映射

• <R, A> R collect(Collector<? super T, A, R> collector) 输出

  终端操作

• Optional<T> min(Comparator<? super T> comparator) 返回最小值

  终端操作

• Optional<T> max(Comparator<? super T> comparator) 返回最大值

  终端操作

• boolean anyMatch(Predicate<? super T> predicate) 是否有一元素满足条件

  终端操作

• boolean allMatch(Predicate<? super T> predicate) 所有元素是否都满足条件

  终端操作

• boolean noneMatch(Predicate<? super T> predicate) 所有元素是否都不满足条件

  终端操作

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

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

• Optional<T> findAny() 返回任一元素

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

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

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

构建流

Collection

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

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

  由一个线程执行操作

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

  可能由多个线程并行执行

Arrays

Java8新增几个方法，返回Stream

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

Stream

• static <T> Stream<T> empty() 返回空流

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

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

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

  流的个数是无限的

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

  流的个数是无限的

Collector

定义

public interface Collector<T, A, R> {
    Supplier<A> supplier();
    BiConsumer<A, T> accumulator();
    BinaryOperator<A> combiner();
    Function<A, R> finisher();
    Set<Characteristics> characteristics();
}

实现原理

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

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

Collectors

容器收集器

• <T, C extends Collection<T>> Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) 通用，接受一个工厂方法作参数

• <T> Collector<T, ?, List<T>> toList()

• <T> Collector<T, ?, Set<T>> toSet()

• <T, K, U> Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)

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

字符串收集器

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

分组

• <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier)
• <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
• <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)

组合式异步编程

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

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

CompletionStage

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

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

CompletableFuture

实现了Future和CompletionStage接口

定义

接受 Supplier 或 Runnable ，不接受 Callable

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

新特性

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

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

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

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

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

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

响应结果和异常

• CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)

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

• CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action)

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

• <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn)

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

• <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn)

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

• CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)

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

构建依赖的任务流

依赖单一阶段的任务流

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

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

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

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

• CompletableFuture<Void> thenAccept(Consumer<? super T> action)

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

• <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn)

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

• <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn)

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

依赖两个阶段的任务流

• CompletableFuture<Void> runAfterBoth(CompletionStage<?> other, Runnable action)

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

• <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action)

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

• <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)

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

• CompletableFuture<Void> runAfterEither(CompletionStage<?> other, Runnable action)

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

• CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action)

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

• <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn)

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

依赖多个阶段的任务流

• CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)

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

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

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

• CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

  同上，构建一个新的任务

  当有任务完成或异常结束时，当前任务相应的完成或异常结束

任务的执行

一般有3类方法

• 名称不带Async的方法由当前线程或前一个阶段的线程执行
• 带Async但没有指定Executor的方法由默认的Executor执行
• 带Async且指定Executor参数的方法由指定的Executor执行