详解Java的 Stream - TinyZ's Blog

Stream是Java 8引入的语法特性。是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。

以下博文基于JAVA 17 LTS版本.

Stream流#

Stream的操作可以分为两大类：中间操作、终结操作

中间操作

无状态（Stateless）操作：指元素的处理不受之前元素的影响
有状态（Stateful）操作：指该操作只有拿到所有元素之后才能继续下去

终结操作

短路（Short-circuiting）操作：指遇到某些符合条件的元素就可以得到最终结果
非短路（Unshort-circuiting）操作：指必须处理完所有元素才能得到最终结果

graph LR Stream-->A(中间操作) A-->A1(无状态操作) A-->A2(状态操作) A1-->filter A1-->map A1-->flatMap A1-->mapMulti A1-->peek A2-->distinct A2-->sorted A2-->skip A2--> A21(短路有状态操作) A21-->limit A21-->takeWhile A21-->dropWhile Stream-->B(终结操作) B-->B1(非短路操作) B1-->forEach B1-->forEachOrdered B1-->reduce B1-->toArray B1-->collect B1-->toList B1-->min B1-->max B1-->count B-->B2(短路操作) B2-->anyMatch B2-->allMatch B2-->noneMatch B2-->findFirst B2-->findAny

Stream 中间操作#

中间操作会逐一获取元素并进行处理。可有可无。所有中间操作都是 惰性的，因此，流在管道中流动之前，任何操作都不会产生任何影响。

无状态操作#

filter：筛选元素，按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。
map: 将集合中的元素A转换成想要得到的B
flatMap: 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
peek: 操作接收的是一个 Consumer 函数

1
//    串行流和并行流设置只会有一个生效，根据调用顺序最终确定。
2
S sequential();    //    串行流
3
S parallel();    //    并行流
4
S unordered();    //    无序化
5
S onClose(Runnable closeHandler);    //    流关闭时处理
6

7
//    元素处理
8
Stream<T> filter(Predicate<? super T> predicate);
9
Stream<T> peek(Consumer<? super T> action);
10
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
11
LongStream mapToLong(ToLongFunction<? super T> mapper);
12
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
13
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
14

15
//    mapMulti系列接口, Java 16增加
16
default <R> Stream<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper) {
17
    Objects.requireNonNull(mapper);
18
    return flatMap(e -> {
19
        SpinedBuffer<R> buffer = new SpinedBuffer<>();
20
        mapper.accept(e, buffer);
21
        return StreamSupport.stream(buffer.spliterator(), false);
22
    });
23
}

有状态操作#

distinct: 元素去重。（根据 Object.equals(Object), 需要重写hashCode()和equals()方法）
sorted：元素排序。
limit：获取流中n个元素返回的流。
skip：在丢弃流的第一个n元素之后，返回由该流的其余元素组成的流。

1
Stream<T> distinct();
2
Stream<T> sorted();
3
Stream<T> sorted(Comparator<? super T> comparator);
4
Stream<T> limit(long maxSize);
5
Stream<T> skip(long n);
6

7
//    Java 9
8
default Stream<T> takeWhile(Predicate<? super T> predicate) {
9
        Objects.requireNonNull(predicate);
10
    return StreamSupport.stream(
11
            new WhileOps.UnorderedWhileSpliterator.OfRef.Taking<>(spliterator(), true, predicate),
12
            isParallel()).onClose(this::close);
13
}
14
default Stream<T> dropWhile(Predicate<? super T> predicate) {
15
        Objects.requireNonNull(predicate);
16
    return StreamSupport.stream(
17
            new WhileOps.UnorderedWhileSpliterator.OfRef.Dropping<>(spliterator(), true, predicate),
18
            isParallel()).onClose(this::close);
19
}

Stream 终结操作#

短路操作#

anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true;
allMatch：Stream 中全部元素符合传入的 predicate，返回 true;
noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true.
findFirst：用于返回满足条件的第一个元素（但是该元素是封装在Optional类中）
findAny：返回流中的任意元素（但是该元素也是封装在Optional类中）

1
boolean anyMatch(Predicate<? super T> predicate);
2
boolean allMatch(Predicate<? super T> predicate);
3
boolean noneMatch(Predicate<? super T> predicate);
4
Optional<T> findFirst();
5
Optional<T> findAny();

非短路操作#

forEach：该方法接收一个Lambda表达式，然后在Stream的每一个元素上执行该表达式
forEachOrdered：该方法接收一个Lambda表达式，然后按顺序在Stream的每一个元素上执行该表达式
reduce：方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值
collect：称为收集器，是一个终端操作,它接收的参数是将流中的元素累积到汇总结果的各种方式
max：根据提供的Comparator返回此流的最大元素
min：根据提供的Comparator返回此流的最小元素
count：返回此流中的元素计数

1
void forEach(Consumer<? super T> action);
2
void forEachOrdered(Consumer<? super T> action);
3
Object[] toArray();
4
<A> A[] toArray(IntFunction<A[]> generator);
5
T reduce(T identity, BinaryOperator<T> accumulator);
6
Optional<T> reduce(BinaryOperator<T> accumulator);
7
<U> U reduce(U identity,
8
            BiFunction<U, ? super T, U> accumulator,
9
            BinaryOperator<U> combiner);
10
<R> R collect(Supplier<R> supplier,
11
            BiConsumer<R, ? super T> accumulator,
12
            BiConsumer<R, R> combiner);
13
<R, A> R collect(Collector<? super T, A, R> collector);
14
default List<T> toList() {
15
    return (List<T>) Collections.unmodifiableList(new ArrayList<>(Arrays.asList(this.toArray())));
16
}
17
Optional<T> min(Comparator<? super T> comparator);
18
Optional<T> max(Comparator<? super T> comparator);
19
long count();

音乐

音乐