java流

July 15, 2022

日前在java 函数式编程中提到了 java 流
前面讲到通过 Stream.iterate() 和 Stream.of() 创建流。
一些数组 API 和集合 API 也提供了转换为流的方法，例如：Arrays.stream() 和 Collection<E> 实例方法 stream()
其它 API 也可能以流的形式提供，例如 java.util.Random 类

此外，除了通用的流（java.util.stream.Stream）外，还提供了几个特化的流：IntStream LongStream DoubleStream 。有关 java8 之后提供的 API，查阅https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/stream/package-summary.html ，详细内容务必查阅 API 文档。

Interface Stream （java.util.stream）

静态方法

Stream.of() Stream.generate() Stream.iterate() 用于生成流。
Stream.empty() 用于生成一个空流。
Stream.concat() 用于合并流。
Stream.builder() 返回流建造者接口，在下一节讨论。

实例方法

java

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    // map 系列函数
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    IntStream mapToInt(ToIntFunction<? super T> mapper);
    LongStream mapToLong(ToLongFunction<? super T> mapper);
    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);

    // 链式调用函数
    Stream<T> distinct();
    Stream<T> sorted();
    Stream<T> sorted(Comparator<? super T> comparator);
    Stream<T> peek(Consumer<? super T> action);
    Stream<T> limit(long maxSize);
    Stream<T> skip(long n);
    Stream<T> filter(Predicate<? super T> predicate);

    // 返回流中元素的数量
    long count();

    // 匹配函数
    boolean anyMatch(Predicate<? super T> predicate);
    boolean allMatch(Predicate<? super T> predicate);
    boolean noneMatch(Predicate<? super T> predicate);

    // 循环函数
    void forEach(Consumer<? super T> action);
    void forEachOrdered(Consumer<? super T> action);

    // 返回Optional的函数
    Optional<T> min(Comparator<? super T> comparator);
    Optional<T> max(Comparator<? super T> comparator);
    Optional<T> findFirst();
    Optional<T> findAny();

    // 转换为数组
    Object[] toArray();
    <A> A[] toArray(IntFunction<A[]> generator);

    // reduce系列函数
    T reduce(T identity, BinaryOperator<T> accumulator);
    Optional<T> reduce(BinaryOperator<T> accumulator);
    <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
    <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
    <R, A> R collect(Collector<? super T, A, R> collector);

    // java 9
    default Stream<T> takeWhile(Predicate<? super T> predicate);
    default Stream<T> dropWhile(Predicate<? super T> predicate);

    // java 16
    default <R> Stream<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper);
    default IntStream mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper);
    default LongStream mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper);
    default DoubleStream mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper);
    default List<T> toList();
}

Interface Stream.Builder （java.util.stream）

此接口继承了 Consumer 接口，没有静态方法。

accept(T t) 方法将 t 添加至流，不返回值
add(T t) 方法将 t 添加至流，返回 Stream.Builder，因此允许链式调用
添加元素后，调用 build() 方法，返回 Stream

Class Optional （java.util）

Optional 容器包装了需要存储的值或对象，因此可以在不使用异常的情况下处理 null

java8 https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html
java17 https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html

扩展阅读

https://www.jishuchi.com/read/onjava8/12013

←Back to home