compact1, compact2, compact3

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>。我们创建一个流对象通过 Widget Collection.stream()，过滤生产流中只有红色的小部件，然后将它转变为一个流的 int值分别代表红色部件的重量。然后将此流相加，以产生一个总重量。

除了Stream，这是一个流对象的引用，有原始的专业IntStream，LongStream，和DoubleStream，所有这些都被称为“流”，符合特征和限制了。

执行计算，流operations组成流管道。蒸汽管道由一个源（可能是一个数组，一个收集、发电功能，I/O通道等），零个或多个中间业务（这将流到另一个流，如filter(Predicate)），和终端操作（产生的结果或副作用，如count()或forEach(Consumer)）。流是懒惰的；源数据的计算只在终端操作启动时执行，而源元素仅在需要时被消耗掉。

集合和流，同时承载一些表面的相似性，有不同的目标。集合主要关心的是有效的管理和访问，他们的元素。相比之下，流不直接访问或操纵元素提供了一种手段，是不是关心声明的描述它们的来源和计算的操作将被执行在源料。但是，如果提供的流操作不提供所需的功能，这BaseStream.iterator()和BaseStream.spliterator()操作可用于执行控制遍历。

一个流管道，像上面的“小部件”示例，可以被看作是流源上的查询。除非源被明确地设计并发修改（如ConcurrentHashMap），不可预知的或错误的行为可能会导致修改流源而被质疑。

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

• 必须non-interfering（他们不修改流源）；和
• 在大多数情况下必须stateless（他们的结果不依赖于任何国家可能的流管道执行期间更改）。

这样的参数一直是一个functional interface如Function实例，经常是lambda表达式或方法引用。除非另有规定，这些参数必须是非空的。

一个流应该被操作（调用一个中间或终端流操作）只有一次。这个规则，例如，“叉”的溪流，在同一源饲料两个或两个以上的管道，或同流多遍历。一个流的实现可能会检测到流被扔IllegalStateException重用。然而，由于一些流操作可能会返回他们的接收器，而不是一个新的流对象，它可能无法检测在所有情况下的重用。

流有BaseStream.close()方法和实施AutoCloseable，但几乎所有的流的情况下，实际上不需要关闭后使用。一般来说，只有溪流的源头是一个IO通道（如那些由Files.lines(Path, Charset)）将需要关闭。大多数流都是由集合、数组或生成函数来支持的，它们不需要特殊的资源管理。（如果流不需要关闭，可以声明为一try-with-resources声明。资源）

流管道可以执行顺序或parallel。这种执行模式是流的属性。流创建具有顺序或并行执行的初始选择。（例如，Collection.stream()创建一个连续的数据流，并Collection.parallelStream()创建一个并行的。）这种选择的执行模式可以由BaseStream.sequential()或BaseStream.parallel()改性的方法，并可以查询与BaseStream.isParallel()方法。

从以下版本开始：

一点八

另请参见：

IntStream， LongStream， DoubleStream， java.util.stream

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	Stream.Builder<T> 一 Stream易变的建设者。

方法摘要

Modifier and Type	Method and Description
boolean	allMatch(Predicate<? super T> predicate) 返回此流中的所有元素是否匹配所提供的谓词。
boolean	anyMatch(Predicate<? super T> predicate) 返回此流中的任何元素是否匹配所提供的谓词。
static <T> Stream.Builder<T>	builder() 返回一个 Stream生成器。
<R,A> R	collect(Collector<? super T,A,R> collector) 执行 mutable reduction操作对元素的使用 Collector流。
<R> R	collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) 执行该流的元素 mutable reduction操作。
static <T> Stream<T>	concat(Stream<? extends T> a, Stream<? extends T> b) 创建一个懒洋洋的级联流的元素的所有元素的第一流通过第二个流的元素。
long	count() 返回此流中元素的计数。
Stream<T>	distinct() 返回一个包含不同的元素流（根据 Object.equals(Object)）这个流。
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<T> s) 返回一个无穷序列无序流，其中每个元素是由提供 Supplier生成。
static <T> Stream<T>	iterate(T seed, UnaryOperator<T> f) 返回一个无穷序列有序 Stream由最初的一元 seed函数的 f迭代应用产生的，产生一个由 seed， f(seed)， f(f(seed)) Stream，等。
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... values) 返回一个元素为指定值的顺序排列的流。
static <T> Stream<T>	of(T t) 返回一个包含一个元素的顺序 Stream。
Stream<T>	peek(Consumer<? super T> action) 返回由该流的元素组成的流，并在所提供的流中执行所提供的每个元素上的动作。
Optional<T>	reduce(BinaryOperator<T> accumulator) 对这一 reduction流元素，使用 associative累积函数，并返回一个 Optional描述价值减少，如果任何。
T	reduce(T identity, BinaryOperator<T> accumulator) 对这一 reduction流元素，使用提供的价值认同和 associative累积函数，返回值减少。
<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排序。
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(" +")));
 

的 mapper函数传递给 flatMap分割线，使用一个简单的正则表达式，为词的数组，然后创建从阵流的话。

参数类型

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());
 

参数

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是负的

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)

对这一 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。

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)

对这一 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。

参数

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:

有谁的签名非常适用于作为参数来 collect()方法参考JDK存在许多类。例如，以下将字符串转换为一个 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)

执行 mutable reduction操作对元素的使用 Collector流。一个 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对象分类，级联两Collectors一起：

     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如果最小元素为null

max

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

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

这是一个terminal operation。

参数

comparator - non-interfering， stateless Comparator比较这流元素

结果

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

异常

NullPointerException -如果最大元素为null

count

long count()

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

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

这是一个terminal operation。

结果

该流中元素的计数

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 -单元

结果

单例顺序流

of

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

返回一个元素为指定值的顺序排列的流。

参数类型

T -流元素的类型

参数

values -新的流元素

结果

新的流

iterate

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

返回一个无穷序列有序 Stream由最初的一元 seed函数的 f迭代应用产生的，产生一个由 seed， f(seed)， f(f(seed)) Stream，等

第一单元（位置0）在Stream将提供seed。对于n > 0，位置n元素，将在位置n - 1元素的应用功能f结果。

参数类型

T -流元素的类型

参数

seed -初始元

f -函数被应用到以前的元素产生一个新的元素

结果

一种新的序列 Stream

generate

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

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

参数类型

T -流元素的类型

参数

s -生成单元 Supplier

结果

一个新的无限序列的无序 Stream

concat

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

创建一个懒洋洋的级联流的元素的所有元素的第一流通过第二个流的元素。将得到的流排序，如果这两个输入流的命令，和并行，如果任一的输入流是平行的。当所产生的流被关闭时，两个输入流的关闭处理程序被调用。

Implementation Note:

当构建流从重复串联谨慎使用。访问一个深深的级联流元件具有较深的调用链，甚至 StackOverflowException。

参数类型

T -流元素的类型

参数

a -第一流

b -二流

结果

这两个输入流连接