类型参数：

T - 流元素的类型

所有超级接口：

AutoCloseable，BaseStream <T，Stream <T >>

公共接口Stream <T>
扩展BaseStream <T，Stream <T >>

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

以来：

1.8

也可以看看：

IntStream， LongStream， DoubleStream， java.util.stream

• 嵌套类摘要

  嵌套类

  修饰符和类型	界面和说明
  static interface	Stream.Builder<T> 一个可变的建设者Stream。

• 方法摘要

  所有方法静态方法实例方法抽象方法默认方法

  修饰符和类型	方法和描述
  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) 使用a对此流的元素执行可变减少操作 Collector。
  <R> R	collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) 对此流的元素执行可变减少操作。
  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通过函数的迭代应用产生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... values) 返回一个顺序排列的流，其元素是指定的值。
  static <T> Stream<T>	of(T t) 返回Stream包含单个元素的顺序。
  Stream<T>	peek(Consumer<? super T> action) 返回由此流的元素组成的流，另外对每个元素执行提供的操作，因为元素将从结果流中消耗。
  Optional<T>	reduce(BinaryOperator<T> accumulator) 使用关联累积函数执行此流的元素 缩减，并返回描述缩小的值（如果有的话）。Optional
  T	reduce(T identity, BinaryOperator<T> accumulator) 使用提供的标识值和关联 累积函数执行此流的元素 缩减，并返回缩小的值。
  <U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner) 使用提供的身份，积累和组合功能，执行此流的元素缩减。
  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函数分配返回的数组，以及分区执行或调整大小时可能需要的其他数组。

  • 从接口java.util.stream继承的方法 BaseStream

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

方法细节

• filter

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

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

  这是一个中间操作。

  参数：

  predicate- 适用于每个元素的非干扰， 无状态谓词，以确定是否应该包含它

  返回：

  新的流

• map

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

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

  这是一个中间操作。

  类型参数：

  R - 新流的元素类型

  参数：

  mapper-一个无干扰， 无状态的 功能应用到每个元素

  返回：

  新的流

• mapToInt

  IntStream  mapToInt（ToIntFunction <？super T > mapper）

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

  这是一个 中间操作。

  参数：

  mapper-一个无干扰， 无状态的 功能应用到每个元素

  返回：

  新的流

• mapToLong

  LongStream  mapToLong（ToLongFunction <？super T > mapper）

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

  这是一个中间操作。

  参数：

  mapper-一个无干扰， 无状态的 功能应用到每个元素

  返回：

  新的流

• mapToDouble

  DoubleStream  mapToDouble（ToDoubleFunction <？super T > mapper）

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

  这是一个中间操作。

  参数：

  mapper-一个无干扰， 无状态的 功能应用到每个元素

  返回：

  新的流

• flatMap

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

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

  这是一个中间操作。

  API注意：

  该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-一个非干扰， 无状态 功能应用到其产生新的值的流的每个元素

  返回：

  新的流

• flatMapToInt

  IntStream  flatMapToInt（Function <？super T，？extends IntStream > mapper）

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

  这是一个中间操作。

  参数：

  mapper-一个非干扰， 无状态 功能应用到其产生新的值的流的每个元素

  返回：

  新的流

  也可以看看：

  flatMap(Function)

• flatMapToLong

  LongStream  flatMapToLong（Function <？super T，？extends LongStream > mapper）

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

  这是一个中间操作。

  参数：

  mapper-一个非干扰， 无状态 功能应用到其产生新的值的流的每个元素

  返回：

  新的流

  也可以看看：

  flatMap(Function)

• flatMapToDouble

  DoubleStream  flatMapToDouble（Function <？super T，？extends DoubleStream > mapper）

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

  这是一个中间操作。

  参数：

  mapper-一个非干扰， 无状态 功能应用到其产生新的值的流的每个元素

  返回：

  新的流

  也可以看看：

  flatMap(Function)

• distinct

  Stream < T > distinct（）

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

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

  这是一个有状态的中间操作。

  API注意：

  distinct()在并行管道中保持稳定性是相对昂贵的（要求操作充当完全屏障，具有大量的缓冲开销），并且通常不需要稳定性。如果您的情况的语义允许，使用无序的流源（如generate(Supplier)）或删除排序约束BaseStream.unordered()可能会导致distinct()在并行管道中显着更高效的执行。如果要求与遇到命令的一致性，并且distinct()在并行管道中遇到性能不佳或内存利用率较低的问题，则切换到顺序执行BaseStream.sequential()可能会提高性能。

  返回：

  新的流

• sorted

  Stream < T > sorted（）

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

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

  这是一个有状态的中间操作。

  返回：

  新的流

• sorted

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

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

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

  这是一个有状态的中间操作。

  参数：

  comparator- 用于比较流元素的无干扰， 无状态 Comparator

  返回：

  新的流

• peek

  Stream < T > peek（Consumer <？super T > action）

  返回由此流的元素组成的流，另外对每个元素执行提供的操作，因为元素将从结果流中消耗。

  这是一个中间操作。

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

  API注意：

  此方法主要用于支持调试，您希望在元素流经管道中的某个点时看到这些元素：

  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- 从流中消耗的对元素执行的无干扰操作

  返回：

  新的流

• limit

  Stream<T> limit(long maxSize)

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

  这是一个短路状态中间操作。

  API注意：

  虽然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元素，那么将返回一个空的流。

  这是一个有状态的中间操作。

  API注意：

  虽然skip()在顺序流管线上通常是一个便宜的操作，但对于有序的并行流水线，特别是对于大数值，这可能是非常昂贵的n，因为skip(n) 被约束不仅跳过任何n个元素，而且还跳过遇到次序中的 前n个元素。如果您的情况的语义允许，使用无序的流源（如generate(Supplier)）或删除排序约束BaseStream.unordered()可能会导致skip()并行管道的显着加速。如果要求与遇到命令的一致性，并且skip()在并行管道中遇到性能不佳或内存利用率 较低的问题，则切换到顺序执行BaseStream.sequential()可能会提高性能。

  参数：

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

  返回：

  新的流

  抛出：

  IllegalArgumentException- 如果n是消极的

• forEach

  void forEach（Consumer <？super T > action）

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

  这是一个终端操作。

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

  参数：

  action- 对元素执行的无干扰行为

• forEachOrdered

  void forEachOrdered（Consumer <？super T > action）

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

  这是一个终端操作。

  这个操作一次处理一个元素，如果存在的话，按照顺序处理。执行一个元素的动作 发生在 为后续元素执行动作之前，但是对于任何给定的元素，动作可以在库选择的任何线程中执行。

  参数：

  action- 对元素执行的无干扰行为

  也可以看看：

  forEach(Consumer)

• toArray

  Object [] toArray（）

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

  这是一个终端操作。

  返回：

  包含此流的元素的数组

• toArray

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

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

  这是一个终端操作。

  API注意：

  生成器函数采用一个整数，它是所需数组的大小，并生成所需大小的数组。这可以用一个数组构造器引用来简洁地表示：

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

  类型参数：

  A - 结果数组的元素类型

  参数：

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

  返回：

  包含此流中元素的数组

  抛出：

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

• reduce

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

  使用提供的标识值和关联 累积函数执行此流的元素 缩减，并返回缩小的值。这相当于：

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

  但不限制顺序执行。

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

  这是一个终端操作。

  API注意：

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

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

  要么：

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

  虽然这可能看起来是一个更简单的方法来执行聚合，而不是简单地将循环中的运行总量进行变异，但是减少操作可以更加平滑地进行并行处理，而不需要额外的同步，并且大大降低了数据竞争的风险。

  参数：

  identity - 积累函数的标识值

  accumulator- 用于组合两个值的关联， 无干扰， 无状态函数

  返回：

  减少的结果

• reduce

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

  使用关联累积函数执行此流的元素 缩减，并返回描述缩小的值（如果有的话）。这相当于： Optional

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

  但不限制顺序执行。

  该accumulator函数必须是一个 关联函数。

  这是一个终端操作。

  参数：

  accumulator- 用于组合两个值的关联， 无干扰， 无状态函数

  返回：

  一个Optional描述减少的结果

  抛出：

  NullPointerException - 如果减少的结果为空

  也可以看看：

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

• reduce

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

  使用提供的身份，积累和组合功能，执行此流的元素缩减。这相当于：

  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)

  这是一个终端操作。

  API注意：

  许多减少使用这种形式可以更简单地通过明确的组合map和reduce操作来表示。该accumulator函数作为一个融合的映射器和累加器，有时比单独的映射和减少更有效率，比如知道以前减少的值可以避免一些计算。

  类型参数：

  U - 结果的类型

  参数：

  identity - 组合函数的标识值

  accumulator-一个缔合， 非干扰性， 无状态 用于将一个额外的元件到结果函数

  combiner-一个缔合， 非干扰， 无状态 功能用于组合两个值，它必须与蓄能器功能兼容

  返回：

  减少的结果

  也可以看看：

  reduce(BinaryOperator)， reduce(Object, BinaryOperator)

• collect

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

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

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

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

  这是一个终端操作。

  API注意：

  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-一个缔合， 非干扰性， 无状态 用于将一个额外的元件到结果函数

  combiner-一个缔合， 非干扰， 无状态 功能用于组合两个值，它必须与蓄能器功能兼容

  返回：

  减少的结果

• collect

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

  使用a对此流的元素执行可变减少操作 Collector。A Collector 将用作参数的函数封装起来 collect(Supplier, BiConsumer, BiConsumer)，从而允许重用收集策略和收集操作的组合，例如多级分组或分区。

  如果流是平行的，并且Collector 是concurrent，并且或者流是无序或集电极是 unordered，那么将执行一个并发减少（见Collector用于并发还原细节）。

  这是一个终端操作。

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

  API注意：

  以下将把字符串累加到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。这是减少的特殊情况 。

  这是一个终端操作。

  参数：

  comparator- 一个无干扰， 无状态 Comparator的比较这个流的元素

  返回：

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

  抛出：

  NullPointerException - 如果最小元素为null

• max

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

  根据提供的内容返回此流的最大元素 Comparator。这是减少的特殊情况 。

  这是一个终端操作。

  参数：

  comparator- 一个无干扰， 无状态 Comparator的比较这个流的元素

  返回：

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

  抛出：

  NullPointerException - 如果最大元素为空

• count

  long count（）

  返回此流中元素的数量。这是一个特殊的情况下降低，等同于：

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

  这是一个终端操作。

  返回：

  这个流中元素的数量

• anyMatch

  boolean anyMatch(Predicate<? super T> predicate)

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

  这是一个短路终端操作。

  API注意：

  这种方法评估流的元素上谓词的存在量化（对于一些x P（x））。

  参数：

  predicate- 适用于这个流的元素的一个无干扰， 无状态的谓词

  返回：

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

• allMatch

  boolean allMatch(Predicate<? super T> predicate)

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

  这是一个短路终端操作。

  API注意：

  这种方法评估流的元素的谓词的通用量化（对于所有x P（x））。如果流是空的，量化被认为是真实的满足，并且总是true（不管P（x））。

  参数：

  predicate- 适用于这个流的元素的一个无干扰， 无状态的谓词

  返回：

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

• noneMatch

  boolean noneMatch(Predicate<? super T> predicate)

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

  这是一个短路终端操作。

  API注意：

  这种方法评估流元素上的否定谓词的通用量化（对于所有x〜P（x））。如果流是空的，则量化被认为是真实地满足，并且总是true，不管P（x）如何。

  参数：

  predicate- 适用于这个流的元素的一个无干扰， 无状态的谓词

  返回：

  true 如果流的任何元素都不匹配提供的谓词，或者流是空的，否则 false

• findFirst

  Optional<T> findFirst()

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

  这是一个短路终端操作。

  返回：

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

  抛出：

  NullPointerException - 如果选择的元素为空

• findAny

  Optional<T> findAny()

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

  这是一个短路终端操作。

  这个操作的行为是明确的不确定的; 它可以自由选择流中的任何元素。这是为了在并行操作中实现最高性能。成本是多个调用在同一来源可能不会返回相同的结果。（如果需要稳定的结果，请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通过函数的迭代应用产生f为初始元素seed，产生Stream包括seed，f(seed)， f(f(seed))，等。

  第一个元素（位置0）Stream将会是提供的seed。为n > 0，在位置上的元素 n，将是将所述函数的结果f在位置到元件n - 1。

  类型参数：

  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）

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

  实施说明：

  从重复连接构造流时要小心。访问深度级联流的元素可能会导致深度调用链，甚至导致深度调用链StackOverflowException。

  类型参数：

  T - 流元素的类型

  参数：

  a - 第一个流

  b - 第二个流

  返回：

  两个输入流的连接