Java8 新特性学习 | 老李的笔记

Stream

基本概念

java.util.Stream 表示了某一种元素的序列，在这些元素上可以进行各种操作。Stream 操作可以是中间操作，也可以是完结操作。完结操作会返回一个某种类型的值，而中间操作会返回流对象本身，并且你可以通过多次调用同一个流操作方法来将操作结果串起来。Stream 是在一个源的基础上创建出来的，例如 java.util.Collection 中的 list 或者 set ( map 不能作为 Stream 的源)。Stream 操作往往可以通过顺序或者并行两种方式来执行。

Stream 和集合的区别

Stream 不会自己存储元素。元素储存在底层集合或者根据需要产生。
Stream 操作符不会改变源对象。相反，它会返回一个持有结果的新的 Stream 。
Stream 操作可能是延迟执行的，这意味着它们会等到需要结果的时候才执行。

Stream 操作的基本过程

创建一个 Stream 。
在一个或者多个操作中，将指定的 Stream 转换为另一个 Stream 的中间操作。
通过终止( terminal )方法来产生一个结果。该操作会强制它之前的延时操作立即执行，这之后该 Stream 就不能再被使用了。

中间操作有 filter, distinct, sorted, map, flatMap 等，其一般是对数据集的整理（过滤, 排序, 匹配, 抽取等）。
终止方法往往是完成对数据集中数据的处理，如 forEach ，还有 allMatch, anyMatch, findAny, findFirst 等，数值计算类的方法有 sum, max, min, average 等。终止方法也可以是对集合的处理，如 reduce, collect 等。 reduce 方法的处理方式一般是每次都产生新的数据集，而 collect 方法是在原数据集的基础上进行更新，过程中不产生新的数据集。

filter

filter 接受一个 Predicate 接口类型的变量，并对所有流对象中的元素进行过滤。该操作是一个中间操作，返回值还是流。

sorted

sorted 是一个中间操作，能够返回一个排过序的流对象的视图。流对象中的元素会默认按照自然顺序进行排序，除非你自己指定一个 Comparator 接口来改变排序规则。

map

map 是一个中间操作，通过给定的方法，它能够把流对象中的每一个元素对应到另外一个对象上。不但如此，你还可以把每一种对象映射成为其他类型。对于带泛型结果的流对象，具体的类型还要由传递给 map 的泛型方法来决定。

match

匹配操作有 anyMatch, allMatch, noneMatch 类型，都是用来判断某一种规则是否与流对象相互吻合的。所有的匹配操作都是终结操作，只返回一个boolean类型的结果。

count

count 是一个终结操作，它的作用是返回一个数值，用来标识当前流对象中包含的元素数量。

reduce

reduce 是一个终结操作，它能够通过某一个方法，对元素进行削减操作。该操作的结果会放在一个 Optional 变量里返回。

Parallel Streams

流操作可以是顺序的，也可以是并行的。顺序操作通过单线程执行，而并行操作则通过多线程执行。

函数式接口

为查看方便，将借口定义去除注释摘抄在此

Predicate

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Function

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Supplier

package java.util.function;

@FunctionalInterface
public interface Supplier<T> {

    T get();
}

Consumer

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}