Stream

allMatch

boolean allMatch (Predicate<? super T> predicate)

返回此流的所有元素是否与提供的谓词匹配。 如果不需要确定结果，则不能评估所有元素的谓词。 如果流为空，则返回true ，并且不评估谓词。

这是一个 short-circuiting terminal operation 。

anyMatch

boolean anyMatch (Predicate<? super T> predicate)

返回此流的任何元素是否与提供的谓词匹配。 如果不需要确定结果，则不能评估所有元素的谓词。 如果流为空，则返回false ，并且不评估谓词。

这是一个 short-circuiting terminal operation 。

builder

Builder<T> builder ()

返回 Stream的构建器。

collect

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

使用Collector对此流的元素执行mutable reduction操作。 A Collector将用作参数的函数封装到collect(Supplier, BiConsumer, BiConsumer) ，允许重用收集策略和组合收集操作，如多级分组或分区。

如果数据流是并行的，并且 Collector是 concurrent ，并且数据流是无序的或者收集器是 unordered ，那么会执行并发的还原（有关并发还原的详细信息，请参阅 Collector ）。

这是一个 terminal operation 。

当并行执行时，可以实例化，填充和合并多个中间结果，以保持可变数据结构的隔离。 因此，即使与非线程安全的数据结构（如ArrayList ）并行执行，也不需要额外的同步来进行并行减少。

collect

R collect (Supplier<R> supplier, 
                BiConsumer<R, ? super T> accumulator, 
                BiConsumer<R, R> combiner)

对此流的元素执行mutable reduction操作。 可变的约简是减少的值是一个可变的结果容器，例如ArrayList ，并且通过更新结果状态而不是通过替换结果来合并元素。 这产生的结果等同于：

R result = supplier.get();
     for (T element : this stream)
         accumulator.accept(result, element);
     return result;
 

与 reduce(Object, BinaryOperator)一样， collect操作可以并行化而不需要额外的同步。

这是一个 terminal operation 。

concat

Stream<T> concat (Stream<? extends T> a, 
                Stream<? extends T> b)

创建一个延迟连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。 如果两个输入流都是有序的，则生成的流是有序的，如果任意一个输入流是并行的，则生成流。 当结果流关闭时，调用两个输入流的关闭处理程序。

count

long count ()

返回此流中元素的数量。 这是reduction的特例 ，相当于：

return mapToLong(e -> 1L).sum();
 

这是一个 terminal operation 。

distinct

Stream<T> distinct ()

返回由此流的不同元素（根据 equals(Object) ）组成的流。

对于有序流，选择不同的元素是稳定的（对于重复的元素，保留在遇到顺序中首先出现的元素）。对于无序流，没有稳定性保证。

这是一个 stateful intermediate operation 。

empty

Stream<T> empty ()

返回一个空的顺序 Stream 。

filter

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

返回包含此流中与给定谓词相匹配的元素的流。

这是一个 intermediate operation 。

findAny

Optional<T> findAny ()

返回描述流的某个元素的 Optional ，或者如果流为空，则返回空 Optional 。

这是一个 short-circuiting terminal operation 。

这种操作的行为显然是不确定的; 它可以自由选择流中的任何元素。 这是为了在并行操作中实现最高性能; 成本是在同一个源上的多个调用可能不会返回相同的结果。 （如果需要稳定的结果， findFirst()改为使用findFirst() ）

findFirst

Optional<T> findFirst ()

返回Optional描述此流的第一个元素，或空Optional如果流是空的。 如果该流没有遇到命令，则可以返回任何元素。

这是一个 short-circuiting terminal operation 。

flatMap

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

返回一个流，该流包含将此流的每个元素替换为通过将所提供的映射函数应用于每个元素而生成的映射流的内容的结果。 将其内容放入此流后，每个映射流都是closed 。 （如果映射流为null ，则使用空流，而不是。）

这是一个 intermediate operation 。

flatMapToDouble

DoubleStream flatMapToDouble (Function<? super T, ? extends DoubleStream> mapper)

返回DoubleStream其中包含将此流的每个元素替换为通过将所提供的映射函数应用于每个元素而生成的映射流的内容的结果。 在其内容放入此流后，每个映射流都是closed 。 （如果映射流为null ，则使用空流而不是。）

这是一个 intermediate operation 。

flatMapToInt

IntStream flatMapToInt (Function<? super T, ? extends IntStream> mapper)

返回IntStream其中包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果。 将其内容放入此流后，每个映射流都是closed 。 （如果映射的流是null ，则使用空流，而不是。）

这是一个 intermediate operation 。

flatMapToLong

LongStream flatMapToLong (Function<? super T, ? extends LongStream> mapper)

返回一个LongStream其中包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果。 将其内容放入此流后，每个映射流都是closed 。 （如果映射流为null ，则使用空流而不是）。

这是一个 intermediate operation 。

forEach

void forEach (Consumer<? super T> action)

为此流的每个元素执行操作。

这是一个 terminal operation 。

这个操作的行为显然是不确定的。 对于并行流管道，此操作并不保证尊重流的相遇顺序，因为这样做会牺牲并行的利益。 对于任何给定的元素，该动作可以在任何时间和库中选择的任何线程中执行。 如果操作访问共享状态，它负责提供所需的同步。

forEachOrdered

void forEachOrdered (Consumer<? super T> action)

为流的每个元素执行操作，如果流具有已定义的遇到顺序，则按流的遇到顺序执行操作。

这是一个 terminal operation 。

该操作一次处理一个元素，如果存在，则按照相遇顺序处理。 执行一个元素的动作happens-before为后续元素执行动作，但对于任何给定的元素，该动作可以在库选择的任何线程中执行。

generate

Stream<T> generate (Supplier<T> s)

返回一个无限顺序无序流，其中每个元素由提供的Supplier生成。 这适用于生成恒定流，随机元素流等。

iterate

Stream<T> iterate (T seed, 
                UnaryOperator<T> f)

返回有序无限连续 Stream由函数的迭代应用产生 f到初始元素 seed ，产生 Stream由 seed ， f(seed) ， f(f(seed))等

第一元件（位置0在） Stream将是提供seed 。 对于n > 0 ，位置n处的元素将是将函数f应用于位置n - 1上的元素的n - 1 。

limit

Stream<T> limit (long maxSize)

返回由此流的元素组成的流，截断长度不超过 maxSize 。

这是一个 short-circuiting stateful intermediate operation 。

map

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

返回由将给定函数应用于此流的元素的结果组成的流。

这是一个 intermediate operation 。

mapToDouble

DoubleStream mapToDouble (ToDoubleFunction<? super T> mapper)

返回一个 DoubleStream其中包含将给定函数应用于此流的元素的结果。

这是一个 intermediate operation 。

mapToInt

IntStream mapToInt (ToIntFunction<? super T> mapper)

返回一个 IntStream其中包含将给定函数应用于此流的元素的结果。

这是一个 intermediate operation 。

mapToLong

LongStream mapToLong (ToLongFunction<? super T> mapper)

返回一个 LongStream其中包含将给定函数应用于此流的元素的结果。

这是一个 intermediate operation 。

max

Optional<T> max (Comparator<? super T> comparator)

根据提供的Comparator返回此流的最大元素。 这是一个reduction的特例 。

这是一个 terminal operation 。

min

Optional<T> min (Comparator<? super T> comparator)

根据提供的Comparator返回此流的最小元素。 这是一个reduction的特例 。

这是一个 terminal operation 。

noneMatch

boolean noneMatch (Predicate<? super T> predicate)

返回此流的元素是否与提供的谓词匹配。 如果不需要确定结果，则不能评估所有元素的谓词。 如果流为空，则返回true ，并且不评估谓词。

这是一个 short-circuiting terminal operation 。

of

Stream<T> of (T t)

返回包含单个元素的顺序 Stream 。

of

Stream<T> of (T... values)

返回顺序排列的流，其元素是指定的值。

peek

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

返回由该流的元素组成的流，并在元素从结果流中消耗时另外对每个元素执行提供的操作。

这是一个 intermediate operation 。

对于并行流管线，可以随时调用该操作，并且可以在任何线程中通过上游操作使该元素可用。 如果该操作修改共享状态，则它负责提供所需的同步。

reduce

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

对此流的元素执行reduction ，使用提供的标识值和associative累加函数，并返回缩小的值。 这相当于：

T result = identity;
     for (T element : this stream)
         result = accumulator.apply(result, element)
     return result;
 

identity值必须是累加器函数的标识。 这意味着，对于所有t ， accumulator.apply(identity, t)等于t 。 accumulator函数必须是associative函数。

这是一个 terminal operation 。

reduce

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

对此流的元素执行reduction ，使用associative累加函数，并返回描述减小值的Optional （如果有）。 这相当于：

boolean foundAny = false;
     T result = null;
     for (T element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.apply(result, element);
     }
     return foundAny ? Optional.of(result) : Optional.empty();
 

accumulator函数必须是 associative函数。

这是一个 terminal operation 。

reduce

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

使用提供的标识，累加和组合函数，对此流的元素执行reduction 。 这相当于：

U result = identity;
     for (T element : this stream)
         result = accumulator.apply(result, element)
     return result;
 

identity值必须是组合函数的标识。 这意味着，对于所有u ， combiner(identity, u)等于u 。 另外， combiner功能必须与accumulator功能兼容; 对于所有的u和t ，以下都必须具备：

combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)
 

这是一个 terminal operation 。

skip

Stream<T> skip (long n)

在丢弃流的第一个n元素后，返回由该流的其余元素组成的流。 如果此流包含少于n元素，则会返回一个空流。

这是一个 stateful intermediate operation 。

sorted

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

返回由该流的元素组成的流，按照提供的 Comparator进行排序。

对于有序流，排序是稳定的。 对于无序的流，没有稳定性保证。

这是一个 stateful intermediate operation 。

sorted

Stream<T> sorted ()

返回由该流的元素组成的流，按照自然顺序排序。 如果此流的元素不是Comparable ，则在执行终端操作时可能会抛出java.lang.ClassCastException 。

对于有序流，排序是稳定的。 对于无序的流，没有稳定性保证。

这是一个 stateful intermediate operation 。

toArray

Object[] toArray ()

返回包含此流的元素的数组。

这是一个 terminal operation 。

toArray

A[] toArray (IntFunction<A[]> generator)

返回包含此流的元素的数组，使用提供的 generator函数分配返回的数组以及分区执行或调整大小时可能需要的任何其他数组。

这是一个 terminal operation 。