Java8 Stream篇章

Stream从入门到离家出走

类似于DB的视图（转换后成为数组、集合或流的视图）
流式操作，用后即无

获得Stream

• Stream.of(T …args)
• Collection.stream()
• Collection.parallelStream()
• Arrays.stream(T[] array)

中间操作

惰性执行，调用此操作仅生成新stream。返回值为stream的大都是中间操作。

常见方法：concat()、distinct()、filter()、flatMap()、limit()、map()、peek()、skip()、sorted()、parallel()、sequential()、unordered()

终止操作

立即触发，调用此操作会立即执行相应业务计算，完成后stream失效。

常见方法：allMatch()、anyMatch()、collect()、count()、findAny()、findFirst()、forEach()、forEachOrdered()、max()、min()、noneMatch()、reduce()、toArray()

方法介绍

void forEach(Consumer<? super E> action)

终止操作。对每个元素执行action操作。

Stream<T> filter(Predicate<? super T> predicate)

中间操作。返回只包含满足predicate条件元素的Stream。

Stream<T> distinct()

中间操作。返回一个去除重复元素之后的Stream。

Stream<T> sorted() && Stream<T> sorted(Comparator<? super T> comparator)

中间操作。返回一个排序后的Stream。

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

中间操作。返回一个对当前所有元素执行执行mapper操作之后的结果组成的Stream

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

中间操作。将给定的子streams拆解重融后有序衔接到父Stream。

Stream<T> peek (Consumer<? super T> action)

中间操作。返回一个所有元素都执行action操作后的Stream。

规约操作

Optional<T> reduce(BinaryOperator<T> accumulator)

accumulator：二元运算操作。参数1：该实现代码的返回值。参数2：stream的迭代值。第一次执行时：参数1，2分别为stream的第1,2个元素。

T reduce(T identity, BinaryOperator<T> accumulator)

identity：初始值。若stream为空则返回该值。方法不会出现null，则无需返回Optional。
accumulator：原理同上。不同：第一次执行时：参数1为初始值，参数2为stream的第一个元素。

<U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)

• identity：初始值
• accumulator：累加器
• combiner：并发操作时，对于reduce线程都会有独立的result，combiner指定多个部分结果result的合并方式。

Optional跳过入门立即搞起

先讲为什么搞

升级过往null对象的处理思维

再讲怎么来搞

先构造，后起航

构造

static <T> Optional<T> of(T value)

生成一个value不为null的Optional

static <T> Optional<T> ofNullable(T value)

若value为null，调用empty()生成一个空的Optional
否则生成一个指定value的Optional

static <T> Optional<T> empty()

生成一个空的Optional

不骗你，这里我只说常用方法

void ifPresent(Consumer<? super T> consumer)

如果有值则执行consumer函数式接口的方法

T orElse(T other)

如果有值则将其返回，否则返回指定的other

T orElseGet(Supplier<? extends T> other)

如果有值则将其返回，否则返回指定的other函数式接口生成的值

<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)

如果有值则将其返回，否则抛出指定的exceptionSupplier函数式接口生成的异常

Optional<T> filter(Predicate<? super T> predicate)

如果有值则执行predicate函数式接口并把包含符合过滤条件值封装成Optional返回，否则返回空的Optional

<U> Optional<U> map(Function<? super T,? extends U> mapper)

如果有值则执行mapper函数式接口并自动将其返回值封装成Optional返回，否则返回空的Optional

<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)

与map方法区别：flatMap不会对结果用Optional封装
如果有值则执行mapper函数式接口并需手动将其返回值封装成Optional返回，否则返回空的Optional

    @Test
public void testOptional() {

    //创建Optional实例
    Optional<String> opt = Optional.of("apple");
    Optional<String>  emptyOpt = Optional.empty();
    Optional<String>  emptyOptOfNull = Optional.ofNullable(null);

    //ifPresent：有值则输出
    opt.ifPresent(val -> System.out.println(val)); // apple
    emptyOpt.ifPresent(val -> System.out.println(val)); // 无输出
    emptyOptOfNull.ifPresent(val -> System.out.println(val)); // 无输出

    // 创建的空值是否相等
    System.out.println(emptyOpt == emptyOptOfNull); // true

    //orElse：默认值
    System.out.println(opt.orElse("opt ：orElse -> default")); // apple
    System.out.println(emptyOpt.orElse("emptyOpt：orElse -> default")); // emptyOpt：orElse -> default

    //orElseGet：lambda表达式赋默认值
    System.out.println(opt.orElseGet(() -> "opt ：orElseGet -> default")); // apple
    System.out.println(emptyOpt.orElseGet(() -> "emptyOpt：orElseGet -> default")); // emptyOpt：orElseGet -> default

    //orElseThrow：空指针异常
    try {
        opt.orElseThrow(NullPointerException::new);
    } catch (Throwable ex) {
        System.out.println("opt ：Exception -> "+ex.getMessage());  // 无输出
    }
    try {
        emptyOpt.orElseThrow(NullPointerException::new);
    } catch (Throwable ex) {
        System.out.println("emptyOpt ：Exception -> "+ex.getMessage()); // emptyOpt ：Exception -> null
    }

    // map：lambda后自动封装成Optional
    Optional<String> optAfterMap = opt.map(val -> val.toUpperCase());
    Optional<String> emptyOptAfterMap = emptyOpt.map(val -> val.toUpperCase());
    System.out.println(optAfterMap.orElse("opt ：map -> default")); // APPLE
    System.out.println(emptyOptAfterMap.orElse("emptyOpt ：map -> default")); // emptyOpt ：map -> default

    //flatMap：lambda后手动封装成Optional
    Optional<String> optAfterFlatMap = opt.flatMap(val -> Optional.of(val.toUpperCase()));
    Optional<String> emptyOptAfterFlatMap = emptyOpt.flatMap(val -> Optional.of(val.toUpperCase()));
    System.out.println(optAfterFlatMap.orElse("opt ：flatMap -> default")); // APPLE
    System.out.println(emptyOptAfterFlatMap.orElse("emptyOpt ：flatMap -> default")); // emptyOpt ：flatMap -> default

    //filter：过滤Optional
    Optional<String> optFilter = opt.filter(val-> val.length() > 3);
    Optional<String> emptyOptFilter = emptyOpt.filter(val-> val.length() > 3);
    System.out.println(optFilter.orElse("opt ：filter -> default")); // apple
    System.out.println(emptyOptFilter.orElse("emptyOpt ：filter -> default")); // emptyOpt ：filter -> default

}