Module java.base

软件包 java.util.stream

Interface Stream<T>

参数类型

T - 流元素的类型

All Superinterfaces:

AutoCloseable ， BaseStream<T,Stream<T>>

public interface Stream<T>
extends BaseStream<T,Stream<T>>

支持顺序和并行聚合操作的一系列元素。 以下示例说明了使用Stream和IntStream的汇总操作：

   int sum = widgets.stream() .filter(w -> w.getColor() == RED) .mapToInt(w -> w.getWeight()) .sum();  

在这个例子中， widgets是一个Collection<Widget> 。 我们通过Collection.stream()创建一个Widget对象的流，过滤它以生成仅包含红色小部件的流，然后将其转换为表示每个红色小部件的权重的int值。 然后将该流相加以产生总重量。

除了Stream ，这是对象引用的流，存在原语特为IntStream ， LongStream ，和DoubleStream ，所有这些都称为“流”和符合此处描述的特征和限制。

为了执行计算，流operations被组合成流管道 。 流管线由源（其可以是阵列，集合，生成函数，I / O通道等），零个或多个中间操作 （其将流转换成另一个流，例如filter(Predicate) ）组成，以及终端操作 （产生结果或副作用，如count()或forEach(Consumer) ）。 流懒惰 源数据上的计算仅在终端操作启动时执行，源元素仅在需要时才被使用。

允许流实现在优化结果的计算方面具有显着的纬度。 例如，如果流实现可以证明它不会影响计算结果，则流实现可以自由地从流流程中删除操作（或整个阶段），并且因此删除行为参数。 这意味着行为参数的副作用可能并不总是执行，除非另有规定（例如通过终端操作forEach和forEachOrdered ），否则不应被依赖。 （有关这种优化的具体示例，请参阅count()操作中记录的API说明。有关详细信息，请参阅流包文档的side-effects部分。）

集合和流动，同时具有一些表面上的相似之处，具有不同的目标。 集合主要关注其元素的有效管理和访问。 相比之下，流不提供直接访问或操纵其元素的手段，而是关心声明性地描述其源和将在该源上进行聚合的计算操作。 但是，如果提供的流操作不提供所需的功能，则可以使用BaseStream.iterator()和BaseStream.spliterator()操作来执行受控遍历。

流管道，如上面的“小部件”示例，可以被视为流源上的查询 。 除非源是明确设计用于并发修改（如ConcurrentHashMap ），否则在查询流源时可能会导致不可预测或错误的行为。

大多数流操作接受描述用户指定行为的参数，例如上述示例中传递给mapToInt的lambda表达式w -> w.getWeight() 。 为了保持正确的行为，这些行为参数 ：

• 必须是non-interfering （他们不修改流源）; 和
• 在大多数情况下必须是stateless （它们的结果不应该依赖于在流管道的执行期间可能改变的任何状态）。

这样的参数总是functional interface的例子 ，如Function ，并且通常是lambda表达式或方法引用。 除非另有说明，否则这些参数必须为非空值 。

流只能运行（调用中间或终端流操作）一次。 这排除了例如“分叉”流，其中相同的源提供两条或多条流水线，或同一流的多遍。 流实现可能会导致IllegalStateException，如果它检测到流被重用。 然而，由于一些流操作可能返回其接收器而不是新的流对象，所以在所有情况下可能无法检测到重用。

Streams具有BaseStream.close()方法并实现AutoCloseable 。 关闭后在流上操作会抛出IllegalStateException 。 大多数流实例在使用后实际上不需要关闭，因为它们由集合，数组或生成函数支持，这些功能不需要特殊的资源管理。 通常，只有源为IO通道的流，例如由Files.lines(Path)返回的流将需要关闭。 如果一个流确实需要关闭，那么它必须作为资源在资源或者类似的控件结构中打开，以确保在操作完成后立即被关闭。

流管线可以顺序执行，也可以在parallel中执行。 此执行模式是流的属性。 流被创建为具有顺序或并行执行的初始选择。 （例如， Collection.stream()创建一个顺序流，并且Collection.parallelStream()创建一个并行的）。执行模式的选择可以由BaseStream.sequential()或BaseStream.parallel()方法修改，并且可以使用BaseStream.isParallel()方法进行查询。

从以下版本开始：

1.8

另请参见：

IntStream ， LongStream ， DoubleStream ， java.util.stream

Nested Class Summary

Nested Classes

Modifier and Type	接口	描述
static interface	Stream.Builder<T>	一个可变的构建器，用于 Stream 。

方法摘要

Modifier and Type	方法	描述
boolean	allMatch(Predicate<? super T> predicate)	返回此流的所有元素是否与提供的谓词匹配。
boolean	anyMatch(Predicate<? super T> predicate)	返回此流的任何元素是否与提供的谓词匹配。
static <T> Stream.Builder<T>	builder()	返回一个 Stream生成器。
<R> R	collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)	对此流的元素执行 mutable reduction操作。
<R,A> R	collect(Collector<? super T,A,R> collector)	使用 Collector对此流的元素执行 mutable reduction操作。
static <T> Stream<T>	concat(Stream<? extends T> a, Stream<? extends T> b)	创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
long	count()	返回此流中的元素数。
Stream<T>	distinct()	返回由该流的不同元素（根据 Object.equals(Object) ）组成的流。
default Stream<T>	dropWhile(Predicate<? super T> predicate)	如果此流被排序，则返回一个流，该流包含该流的剩余元素，在丢弃与给定谓词匹配的元素的最长前缀之后。
static <T> Stream<T>	empty()	返回空序列 Stream 。
Stream<T>	filter(Predicate<? super T> predicate)	返回由与此给定谓词匹配的此流的元素组成的流。
Optional<T>	findAny()	返回Optional描述流的一些元件，或一个空Optional如果流是空的。
Optional<T>	findFirst()	返回Optional描述此流的第一个元素，或空Optional如果流是空的。
<R> Stream<R>	flatMap(Function<? super T,? extends Stream<? extends R>> mapper)	返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。
DoubleStream	flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)	返回一个 DoubleStream其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
IntStream	flatMapToInt(Function<? super T,? extends IntStream> mapper)	返回一个 IntStream其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
LongStream	flatMapToLong(Function<? super T,? extends LongStream> mapper)	返回一个 LongStream其中包含将该流的每个元素替换为通过将提供的映射函数应用于每个元素而产生的映射流的内容的结果。
void	forEach(Consumer<? super T> action)	对此流的每个元素执行操作。
void	forEachOrdered(Consumer<? super T> action)	如果流具有定义的遇到顺序，则以流的遇到顺序对该流的每个元素执行操作。
static <T> Stream<T>	generate(Supplier<? extends T> s)	返回无限顺序无序流，其中每个元素由提供的 Supplier生成。
static <T> Stream<T>	iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)	返回通过将给定的 next函数迭代应用于初始元素 Stream产生的顺序 Stream ，其条件是满足给定的 hasNext谓词。
static <T> Stream<T>	iterate(T seed, UnaryOperator<T> f)	返回有序无限连续 Stream由函数的迭代应用产生 f到初始元素 seed ，产生 Stream由 seed ， f(seed) ， f(f(seed))等
Stream<T>	limit(long maxSize)	返回由此流的元素组成的流，截短长度不能超过 maxSize 。
<R> Stream<R>	map(Function<? super T,? extends R> mapper)	返回由给定函数应用于此流的元素的结果组成的流。
DoubleStream	mapToDouble(ToDoubleFunction<? super T> mapper)	返回一个 DoubleStream其中包含将给定函数应用于此流的元素的结果。
IntStream	mapToInt(ToIntFunction<? super T> mapper)	返回一个 IntStream其中包含将给定函数应用于此流的元素的结果。
LongStream	mapToLong(ToLongFunction<? super T> mapper)	返回一个 LongStream其中包含将给定函数应用于此流的元素的结果。
Optional<T>	max(Comparator<? super T> comparator)	根据提供的 Comparator返回此流的最大元素。
Optional<T>	min(Comparator<? super T> comparator)	根据提供的 Comparator返回此流的最小元素。
boolean	noneMatch(Predicate<? super T> predicate)	返回此流的元素是否与提供的谓词匹配。
static <T> Stream<T>	of(T t)	返回包含单个元素的序列 Stream 。
static <T> Stream<T>	of(T... values)	返回其元素是指定值的顺序排序流。
static <T> Stream<T>	ofNullable(T t)	返回包含单个元素的序列 Stream ，如果非空，则返回一个空的 Stream 。
Stream<T>	peek(Consumer<? super T> action)	返回由该流的元素组成的流，另外在从生成的流中消耗元素时对每个元素执行提供的操作。
Optional<T>	reduce(BinaryOperator<T> accumulator)	使用 associative累积函数对此流的元素执行 reduction ，并返回描述减小值（如果有）的 Optional 。
T	reduce(T identity, BinaryOperator<T> accumulator)	使用提供的身份值和 associative累积函数对此流的元素执行 reduction ，并返回减小的值。
<U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)	使用提供的身份，积累和组合功能，对此流的元素执行 reduction 。
Stream<T>	skip(long n)	在丢弃流的第一个 n元素后，返回由该流的剩余元素组成的流。
Stream<T>	sorted()	返回由此流的元素组成的流，根据自然顺序排序。
Stream<T>	sorted(Comparator<? super T> comparator)	返回由该流的元素组成的流，根据提供的 Comparator进行排序。
default Stream<T>	takeWhile(Predicate<? super T> predicate)	如果此流被排序，则返回一个流，该流由与此给定谓词匹配的从该流获取的元素的最长前缀组成。
Object[]	toArray()	返回一个包含此流的元素的数组。
<A> A[]	toArray(IntFunction<A[]> generator)	使用提供的 generator函数返回一个包含此流的元素的数组，以分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。

Methods inherited from interface java.util.stream.BaseStream

close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

方法详细信息

filter

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

返回由与此给定谓词匹配的此流的元素组成的流。

这是一个intermediate operation 。

参数

predicate -一个 non-interfering ， stateless谓词应用到每个元素，以确定是否它应包含

结果

新的流

map

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

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

这是一个intermediate operation 。

参数类型

R - 新流的元素类型

参数

mapper -一个 non-interfering ， stateless函数应用到每个元件

结果

新的流

mapToInt

IntStream mapToInt(ToIntFunction<? super T> mapper)

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

这是一个intermediate operation 。

参数

mapper -一个 non-interfering ， stateless函数应用到每个元件

结果

新的流

mapToLong

LongStream mapToLong(ToLongFunction<? super T> mapper)

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

这是一个intermediate operation 。

参数

mapper -一个 non-interfering ， stateless函数应用到每个元件

结果

新的流

mapToDouble

DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)

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

这是一个intermediate operation 。

参数

mapper -一个 non-interfering ， stateless函数应用到每个元件

结果

新的流

flatMap

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

返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。 每个映射的流在其内容被放入此流之后是closed 。 （如果映射的流为null ，则使用空的流。）

这是一个intermediate operation 。

API Note:

flatMap()操作具有将一对多变换应用于流的元素，然后将所得到的元素平坦化为新流的效果。

例子。

如果orders是采购订单流，并且每个采购订单都包含订单项集合，则以下产生包含所有订单中所有订单项的流：

   orders.flatMap(order -> order.getLineItems().stream())...  

如果path是文件的路径，则以下内容将生成包含在该文件中的words的流：

   Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8); Stream<String> words = lines.flatMap(line -> Stream.of(line.split(" +")));  

传递给flatMap的mapper函数将一行（使用简单的正则表达式）分割成一个单词数组，然后从该数组中创建一个单词。

参数类型

R - 新流的元素类型

参数

mapper -一个 non-interfering ， stateless功能应用到其产生新的值的流的每个元素

结果

新的流

flatMapToInt

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

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

这是一个intermediate operation 。

参数

mapper -一个 non-interfering ， stateless功能应用到其产生新的值的流的每个元素

结果

新的流

另请参见：

flatMap(Function)

flatMapToLong

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

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

这是一个intermediate operation 。

参数

mapper -一个 non-interfering ， stateless功能应用到其产生新的值的流的每个元素

结果

新的流

另请参见：

flatMap(Function)

flatMapToDouble

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

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

这是一个intermediate operation 。

参数

mapper -一个 non-interfering ， stateless功能应用到其产生新的值的流的每个元素

结果

新的流

另请参见：

flatMap(Function)

distinct

Stream<T> distinct()

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

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

这是一个stateful intermediate operation 。

API Note:

在并行管道中保持distinct()稳定性相对较高（要求操作充当完全障碍，具有实质的缓冲开销），并且通常不需要稳定性。 如果您的情况允许，则使用无序流源（如generate(Supplier) ）或使用BaseStream.unordered()删除排序约束可能会导致并行流水线中distinct()执行效率显着提高。 如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与distinct()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。

结果

新的流

sorted

Stream<T> sorted()

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

对于有序流，排序稳定。 对于无序的流，不能保证稳定性。

这是一个stateful intermediate operation 。

结果

新的流

sorted

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

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

对于有序流，排序稳定。 对于无序的流，不能保证稳定性。

这是一个stateful intermediate operation 。

参数

comparator -一个 non-interfering ， stateless Comparator到用于比较流元素

结果

新的流

peek

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

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

这是一个intermediate operation 。

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

API Note:

该方法主要用于支持调试，您希望在流程中流过某个特定点时查看元素：

   Stream.of("one", "two", "three", "four") .filter(e -> e.length() > 3) .peek(e -> System.out.println("Filtered value: " + e)) .map(String::toUpperCase) .peek(e -> System.out.println("Mapped value: " + e)) .collect(Collectors.toList());  

在情况下，流实现能够优化掉生产一些或所有的元件（如与像短路操作findFirst ，或在所描述的示例count() ），动作将不被调用这些元素。

参数

action - 一个 non-interfering要从流中消耗的元素执行的操作

结果

新的流

limit

Stream<T> limit(long maxSize)

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

这是一个short-circuiting stateful intermediate operation 。

API Note:

虽然limit()通常是在顺序流管线上的廉价操作，但是在有序并行流水线上可能是相当昂贵的，特别是对于maxSize大值，因为limit(n)被限制为不仅返回任何n个元素，而且在遇到顺序中的前n个元素。 使用无序流源（例如generate(Supplier) ）或去除所述排序约束与BaseStream.unordered()可能导致显著加速比limit()在并行管线，如果情况许可的语义。 如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与limit()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。

参数

maxSize - 流应该限制的元素数量

结果

新的流

异常

IllegalArgumentException - 如果 maxSize为负数

skip

Stream<T> skip(long n)

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

这是一个stateful intermediate operation 。

API Note:

虽然skip()通常是在顺序流管线上的廉价操作，但是在有序的并行流水线上可能是相当昂贵的，特别是对于n大值，因为skip(n)被限制为不仅跳过任何n个元素，而且在遇到顺序中的前n个元素。 使用无序流源（例如generate(Supplier) ）或去除所述排序约束与BaseStream.unordered()可能导致显著加速比skip()在并行管线，如果情况许可的语义。 如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与skip()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。

参数

n - 要跳过的主要元素的数量

结果

新的流

异常

IllegalArgumentException - 如果 n为负数

takeWhile

default Stream<T> takeWhile(Predicate<? super T> predicate)

如果此流被排序，则返回一个流，该流由与此给定谓词匹配的从该流获取的元素的最长前缀组成。 否则返回，如果该流是无序的，则由从与该给定谓词匹配的该流中取得的元素的子集组成的流。

如果该流被排序，则最长的前缀是与给定谓词匹配的该流的连续的元素序列。 序列的第一个元素是此流的第一个元素，并且紧跟该序列的最后一个元素的元素与给定谓词不匹配。

如果该流是无序的，并且该流的一些（但不是全部）元素与给定的谓词匹配，则该操作的行为是非确定性的; 可以自由地采取匹配元素的任何子集（包括空集）。

独立于该流是否被排序或无序，如果此流的所有元素与给定谓词匹配，则此操作将采用所有元素（结果与输入相同），或者如果流的元素与给定谓词匹配，则没有元素被采取（结果是一个空的流）。

这是一个short-circuiting stateful intermediate operation 。

API Note:

虽然takeWhile()通常是顺序流管线上的廉价操作，但是在有序并行流水线上可能相当昂贵，因为操作被限制为不仅返回任何有效的前缀，而且返回遇到顺序中的元素的最长前缀。 使用无序流源（例如generate(Supplier) ）或去除所述排序约束与BaseStream.unordered()可能导致显著加速比takeWhile()在并行管线，如果情况许可的语义。 如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与takeWhile()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。

实现要求：

默认实现获取此流的spliterator ，包装该分割器，以便在遍历时支持此操作的语义，并返回与包装剪辑器相关联的新流。 返回的流保留此流的执行特性（即按照BaseStream.isParallel()进行并行或顺序执行），但是封装的spliterator可能选择不支持拆分。 当返回的流关闭时，将调用返回的流和此流的关闭处理程序。

参数

predicate -一个 non-interfering ， stateless谓词适用于元素，以确定元素的最长前缀。

结果

新的流

从以下版本开始：

9

dropWhile

default Stream<T> dropWhile(Predicate<? super T> predicate)

如果此流被排序，则返回一个流，该流包含该流的剩余元素，在丢弃与给定谓词匹配的元素的最长前缀之后。 否则返回，如果该流是无序的，则在丢弃与给定谓词匹配的元素的子集之后，返回由该流的剩余元素组成的流。

如果该流被排序，则最长的前缀是与给定谓词匹配的该流的连续的元素序列。 序列的第一个元素是此流的第一个元素，并且紧跟该序列的最后一个元素的元素与给定谓词不匹配。

如果该流是无序的，并且该流的一些（但不是全部）元素与给定的谓词匹配，则该操作的行为是非确定性的; 可以放置匹配元素的任何子集（包括空集合）。

独立于该流是否被排序或无序，如果此流的所有元素与给定谓词匹配，则此操作将删除所有元素（结果为空流），或者如果流中的元素与给定谓词匹配，则不会删除元素（结果与输入相同）。

这是一个stateful intermediate operation 。

API Note:

虽然dropWhile()通常是顺序流管线上的便宜操作，但是在有序并行流水线上可能相当昂贵，因为操作被限制为不仅返回任何有效的前缀，而且返回遇到顺序中元素的最长前缀。 如果您的情况允许，则使用无序流源（如generate(Supplier) ）或使用BaseStream.unordered()删除排序约束可能会导致并行流水线显着加速dropWhile() 。 如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与dropWhile()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。

实现要求：

默认实现获取此流的spliterator ，包装该分隔符，以便在遍历时支持此操作的语义，并返回与包装拼接器相关联的新流。 返回的流保留该流的执行特性（即根据BaseStream.isParallel()并行或顺序执行），但是封装的分割器可能选择不支持拆分。 当返回的流关闭时，将调用返回的流和此流的关闭处理程序。

参数

predicate -一个 non-interfering ， stateless谓词适用于元素，以确定元素的最长前缀。

结果

新的流

从以下版本开始：

9

forEach

void forEach(Consumer<? super T> action)

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

这是一个terminal operation 。

这个操作的行为显然是不确定的。 对于并行流管道，此操作不能保证遵守流的遇到顺序，因为这样做会牺牲并行性的好处。 对于任何给定的元素，动作可以在图书馆选择的任何时间和任何线索中执行。 如果操作访问共享状态，则负责提供所需的同步。

参数

action - 要对元素执行的 non-interfering操作

forEachOrdered

void forEachOrdered(Consumer<? super T> action)

如果流具有定义的遇到顺序，则以流的遇到顺序对该流的每个元素执行操作。

这是一个terminal operation 。

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

参数

action - 要对元素执行的 non-interfering操作

另请参见：

forEach(Consumer)

toArray

Object[] toArray()

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

这是一个terminal operation 。

结果

一个包含此流的元素的数组

toArray

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

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

这是一个terminal operation 。

API Note:

发生器函数采用一个整数，它是所需数组的大小，并产生一个所需大小的数组。 这可以用数组构造函数引用简明扼要地表达：

   Person[] men = people.stream() .filter(p -> p.getGender() == MALE) .toArray(Person[]::new);  

参数类型

A - 结果数组的元素类型

参数

generator - 产生所需类型和所提供长度的新数组的函数

结果

一个包含此流中的元素的数组

异常

ArrayStoreException - 如果从数组生成器返回的数组的运行时类型不是此流中每个元素的运行时类型的超类型

reduce

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

使用提供的身份值和associative累积功能对此流的元素执行reduction ，并返回减小的值。 这相当于：

   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 。

API Note:

总和，最小，最大，平均和字符串连接都是减少的特殊情况。 一个数字流可以表示为：

   Integer sum = integers.reduce(0, (a, b) -> a+b);  

要么：

   Integer sum = integers.reduce(0, Integer::sum);  

尽管与简单地将循环中的总体变量相比，这可能看起来更为迂回的方式进行，但减少操作更平稳地并行化，而不需要额外的同步，并大大降低了数据竞争的风险。

参数

identity - 累积函数的身份值

accumulator -一个 associative ， non-interfering ， stateless功能组合两个值

结果

减少的结果

reduce

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

使用associative累积函数对此流的元素执行reduction ，并返回描述减小值（如果有）的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 。

参数

accumulator -一个 associative ， non-interfering ， stateless功能组合两个值

结果

一个Optional描述了减少的结果

异常

NullPointerException - 如果减少的结果为空

另请参见：

reduce(Object, BinaryOperator) ， min(Comparator) ， max(Comparator)

reduce

<U> 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 。

API Note:

使用这种形式的许多减少可以通过map和reduce操作的显式组合来更简单地表示。 accumulator函数充当融合映射器和累加器，这有时比单独的映射和缩减更有效，例如当知道先前减小的值允许您避免某些计算时。

参数类型

U - 结果的类型

参数

identity - 组合器功能的标识值

accumulator -一个 associative ， non-interfering ， stateless功能用于将一个额外的元件到结果

combiner -一个 associative ， non-interfering ， stateless功能用于组合两个值，它必须与蓄能器功能兼容

结果

减少的结果

另请参见：

reduce(BinaryOperator) ， reduce(Object, BinaryOperator)

collect

<R> 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 。

API Note:

JDK中有很多现有的类，其签名非常适合与方法引用一起使用，作为collect()参数。 例如，以下将会将字符串累加到一个ArrayList ：

   List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);  

以下将使用一串字符串并将它们连接成一个字符串：

   String concat = stringStream.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append) .toString();  

参数类型

R - 可变结果容器的类型

参数

supplier - 创建一个新的可变结果容器的函数。 对于并行执行，可以多次调用此函数，并且每次都必须返回一个新的值。

accumulator -一个 associative ， non-interfering ， stateless功能必须的元件折叠成的结果容器。

combiner -一个associative ， non-interfering ， stateless函数接受两个部分结果的容器和将它们合并，这必须与累加器功能兼容。 组合器功能必须将第二个结果容器中的元素折叠到第一个结果容器中。

结果

减少的结果

collect

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

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

如果流是并行的，并且Collector是concurrent ，并且流是无序的或收集器是unordered ，则将执行并发减少（有关并发减少的细节，请参阅Collector ）。

这是一个terminal operation 。

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

API Note:

以下将将字符串累加到一个ArrayList中：

   List<String> asList = stringStream.collect(Collectors.toList());  

以下将按城市分类Person对象：

   Map<String, List<Person>> peopleByCity = personStream.collect(Collectors.groupingBy(Person::getCity));  

以下将按状态和城市分类Person对象，将两个Collector连接在一起：

   Map<String, Map<String, List<Person>>> peopleByStateAndCity = personStream.collect(Collectors.groupingBy(Person::getState, Collectors.groupingBy(Person::getCity)));  

参数类型

R - 结果的类型

A -所述的中间累积型 Collector

参数

collector - 描述减少的 Collector

结果

减少的结果

另请参见：

collect(Supplier, BiConsumer, BiConsumer) ， Collectors

min

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

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

这是一个terminal operation 。

参数

comparator -一个 non-interfering ， stateless Comparator比较该流的元素

结果

一个 Optional描述该流的一个空的最小元件，或 Optional如果流是空

异常

NullPointerException - 如果最小元素为空

max

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

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

这是一个terminal operation 。

参数

comparator -一个 non-interfering ， stateless Comparator比较该流的元素

结果

一个 Optional描述此流的最大元素，或空 Optional如果流是空

异常

NullPointerException - 如果最大元素为空

count

long count()

返回此流中的元素数。 这是一个reduction的特殊情况，相当于：

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

这是一个terminal operation 。

API Note:

如果能够直接从流源计算计数，则实现可以选择不执行流管线（顺序地或并行地）。 在这种情况下，不会遍历源元素，并且不会评估中间操作。 除了无害的情况（如调试），强烈不鼓励具有副作用的行为参数可能会受到影响。 例如，考虑以下流：

   List<String> l = Arrays.asList("A", "B", "C", "D"); long count = l.stream().peek(System.out::println).count();  

流源（ List覆盖的元素数量是已知的，中间操作（ peek ）不会从流中注入或移除元素（如flatMap或filter操作的情况）。 因此，计数是List的大小，并且不需要执行管道，并且作为副作用，打印列表元素。

结果

这个流中元素的数量

anyMatch

boolean anyMatch(Predicate<? super T> predicate)

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

这是一个short-circuiting terminal operation 。

API Note:

该方法评估了流的元素（对于某些x P（x））的谓词的 存在量化 。

参数

predicate -一个 non-interfering ， stateless谓词适用于该流的元素

结果

true如果流的任何元素匹配提供的谓词，否则为 false

allMatch

boolean allMatch(Predicate<? super T> predicate)

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

这是一个short-circuiting terminal operation 。

API Note:

该方法评估了流的元素（对于所有x P（x））的谓词的通用量化 。 如果流是空的，量化据说是空洞地满意 ，始终是true （不管的P（X））。

参数

predicate -一个 non-interfering ， stateless谓词适用于该流的元素

结果

true如果流的所有元素匹配提供的谓词或流为空，否则为 false

noneMatch

boolean noneMatch(Predicate<? super T> predicate)

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

这是一个short-circuiting terminal operation 。

API Note:

该方法评估了流的元素（对于所有x〜P（x））的否定谓词的通用量化 。 如果流是空的，那么量化被认为是空虚的，并且始终是true ，不论P（x）如何。

参数

predicate -一个 non-interfering ， stateless谓词适用于该流的元素

结果

true如果流中没有元素匹配提供的谓词或流为空，否则为 false

findFirst

Optional<T> findFirst()

返回Optional描述此流的第一个元素，或空Optional如果流是空的。 如果流没有遇到顺序，则可能会返回任何元素。

这是一个short-circuiting terminal operation 。

结果

一个 Optional描述此流的第一个元素，或空 Optional如果流是空

异常

NullPointerException - 如果选择的元素为空

findAny

Optional<T> findAny()

返回Optional描述流的一些元件，或一个空Optional如果流是空的。

这是一个short-circuiting terminal operation 。

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

结果

一个 Optional描述该流的一些元件，或一个空 Optional如果流是空

异常

NullPointerException - 如果选择的元素为空

另请参见：

findFirst()

builder

static <T> Stream.Builder<T> builder()

返回一个 Stream的构建器。

参数类型

T - 元素的类型

结果

流构建器

empty

static <T> Stream<T> empty()

返回空序列 Stream 。

参数类型

T - 流元素的类型

结果

一个空的顺序流

of

static <T> Stream<T> of(T t)

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

参数类型

T - 流元素的类型

参数

t - 单个元素

结果

单例顺序流

ofNullable

static <T> Stream<T> ofNullable(T t)

返回包含单个元素的序列 Stream ，如果非空，则返回一个空的 Stream 。

参数类型

T - 流元素的类型

参数

t - 单一元素

结果

如果指定的元素为非空，则具有单个元素的流，否则为空流

从以下版本开始：

9

of

@SafeVarargs
static <T> Stream<T> of(T... values)

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

参数类型

T - 流元素的类型

参数

values - 新流的元素

结果

新的流

iterate

static <T> 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 。

施加的作用f为一个元件happens-before施加的作用f用于随后的元件。 对于任何给定的元素，动作可以在库选择的任何线程中执行。

参数类型

T - 流元素的类型

参数

seed - 初始元素

f - 要应用于前一个元素以生成新元素的函数

结果

一个新的顺序 Stream

iterate

static <T> Stream<T> iterate(T seed,
                             Predicate<? super T> hasNext,
                             UnaryOperator<T> next)

返回通过将给定的next函数迭代应用于初始元素Stream产生的顺序Stream ，其条件是满足给定的hasNext谓词。 一旦hasNext谓词返回false，流即终止。

Stream.iterate应该产生与相应的for-loop相同的元素序列：

   for (T index=seed; hasNext.test(index); index = next.apply(index)) { ... }  

如果hasNext谓词不持有种子值，则结果序列可能为空。 否则第一个元素将是提供的seed值，下一个元素（如果存在）将是将next函数应用于seed值的结果，等等，直到hasNext谓词指示流应该终止。

将hasNext谓词应用于元素happens-before next功能应用于该元素的动作。 在为一个元素应用next函数的动作发生在为后续元素应用hasNext谓词的动作之前 。 对于任何给定的元素，可以在库选择的任何线程中执行一个动作。

参数类型

T - 流元素的类型

参数

seed - 初始元素

hasNext - 应用于元素以确定流何时终止的谓词。

next - 要应用于前一个元素以生成新元素的函数

结果

一个新的顺序 Stream

从以下版本开始：

9

generate

static <T> Stream<T> generate(Supplier<? extends T> s)

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

参数类型

T - 流元素的类型

参数

s - Supplier的生成元素

结果

一个新的无限顺序无序 Stream

concat

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

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

Implementation Note:

在重复连接构建流时要小心。 访问深层级流的元素可能导致深度的调用链，甚至可能导致StackOverflowError 。

对返回流的顺序/并行执行模式的后续更改不能保证传播到输入流。

参数类型

T - 流元素的类型

参数

a - 第一个流

b - 第二个流

结果

两个输入流的并置