支持顺序和并行聚合操作的一系列元素。 以下示例说明了使用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表达式或方法引用。 除非另有说明，否则这些参数必须为非null 。

应该只对一个流进行操作（调用中间或终端流操作）。 例如，这排除了“分叉”流，其中相同的源提供两个或更多个管道，或者同一个流的多个遍历。 如果流实现检测到正在重用流，则可能会抛出IllegalStateException 。 但是，由于某些流操作可能返回其接收器而不是新的流对象，因此可能无法在所有情况下检测重用。

Streams具有BaseStream.close()方法并实现AutoCloseable 。 在关闭后在流上操作将抛出IllegalStateException 。 大多数流实例实际上不需要在使用后关闭，因为它们由集合，数组或生成函数支持，不需要特殊的资源管理。 通常，只有源为IO通道的流（例如Files.lines(Path)返回的流 ）才需要关闭。 如果流确实需要关闭，则必须在try-with-resources语句或类似控制结构中将其作为资源打开，以确保在操作完成后立即关闭它。

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

适用于 Stream可变构建器。 返回此流的所有元素是否与提供的谓词匹配。 返回此流的任何元素是否与提供的谓词匹配。 返回 Stream的构建器。 对此流的元素执行 mutable reduction操作。 使用 Collector对此流的元素执行 mutable reduction操作。 创建一个延迟连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。 返回此流中元素的数量。 返回由此流的不同元素（根据 Object.equals(Object) ）组成的流。 如果对此流进行排序，则返回在删除与给定谓词匹配的元素的最长前缀之后由该流的其余元素组成的流。 返回空序列 Stream 。 返回由与此给定谓词匹配的此流的元素组成的流。 返回Optional描述流的一些元件，或一个空Optional如果流是空的。 返回Optional描述此流的第一个元素，或空Optional如果流是空的。 返回一个流，该流包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果。 返回 DoubleStream其中包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果。 返回 IntStream其中包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果。 返回 LongStream其中包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果。 对此流的每个元素执行操作。 如果流具有已定义的遭遇顺序，则按流的遭遇顺序对此流的每个元素执行操作。 返回无限顺序无序流，其中每个元素由提供的 Supplier生成。 返回通过将给定的 next函数迭代应用于初始元素 Stream生成的顺序有序 Stream ，条件是满足给定的 hasNext谓词。 返回有序无限连续 Stream由函数的迭代应用产生 f到初始元素 seed ，产生 Stream组成的 seed ， f(seed) ， f(f(seed))等 返回由此流的元素组成的流，截断长度不超过 maxSize 。 返回一个流，该流包含将给定函数应用于此流的元素的结果。 返回 DoubleStream其中包含将给定函数应用于此流的元素的结果。 返回 IntStream其中包含将给定函数应用于此流的元素的结果。 返回 LongStream其中包含将给定函数应用于此流的元素的结果。 根据提供的 Comparator返回此流的最大元素。 根据提供的 Comparator返回此流的最小元素。 返回此流的元素是否与提供的谓词匹配。 返回包含单个元素的顺序 Stream 。 返回其元素为指定值的顺序有序流。 返回包含单个元素的顺序 Stream （如果为非null），否则返回空 Stream 。 返回由此流的元素组成的流，另外在每个元素上执行提供的操作，因为元素是从结果流中消耗的。 使用 associative累积函数对此流的元素执行 reduction ，并返回描述减少值的 Optional （如果有）。 使用提供的标识值和 associative累积函数对此流的元素执行 reduction ，并返回减小的值。 使用提供的标识，累积和组合功能对此流的元素执行 reduction 。 在丢弃流的第一个 n元素后，返回由此流的其余元素组成的流。 返回由此流的元素组成的流，按照自然顺序排序。 返回由此流的元素组成的流，根据提供的 Comparator进行排序。 如果对此流进行排序，则返回一个流，该流包含从此流中获取的与给定谓词匹配的最长元素前缀。 返回包含此流的元素的数组。 返回包含此流元素的数组，使用提供的 generator函数分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。 返回由与此给定谓词匹配的此流的元素组成的流。

这是一个intermediate operation 。

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

这是一个intermediate operation 。

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

这是一个intermediate operation 。

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

这是intermediate operation 。

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

这是一个intermediate operation 。

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

这是一个intermediate operation 。

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

这是一个intermediate operation 。

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

这是一个intermediate operation 。

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

这是一个intermediate operation 。

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

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

这是一个stateful intermediate operation 。

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

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

这是一个stateful intermediate operation 。

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

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

这是一个stateful intermediate operation 。

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

这是一个intermediate operation 。

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

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

这是一个short-circuiting stateful intermediate operation 。

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

这是一个stateful intermediate operation 。

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

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

如果此流是无序的，并且此流的某些（但不是所有）元素与给定谓词匹配，则此操作的行为是不确定的; 它可以自由地获取匹配元素的任何子集（包括空集）。

如果此流的所有元素与给定谓词匹配，则此流是有序还是无序，无论此操作是否接受所有元素（结果与输入相同），或者如果流的任何元素都不匹配给定谓词，则没有元素被采取（结果是一个空流）。

这是一个short-circuiting stateful intermediate operation 。

如果对此流进行排序，则返回在删除与给定谓词匹配的元素的最长前缀之后由该流的其余元素组成的流。 否则，如果此流是无序的，则返回在删除与给定谓词匹配的元素子集之后由该流的其余元素组成的流。

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

如果此流是无序的，并且此流的某些（但不是所有）元素与给定谓词匹配，则此操作的行为是不确定的; 它可以自由地删除匹配元素的任何子集（包括空集）。

如果此流的所有元素与给定谓词匹配，则该流是有序还是无序，无论该操作是否丢弃所有元素（结果是空流），或者如果流的任何元素都不匹配给定谓词，则不会丢弃任何元素（结果与输入相同）。

这是一个stateful intermediate operation 。

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

这是terminal operation 。

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

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

这是一个terminal operation 。

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

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

这是一个terminal operation 。

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

这是一个terminal operation 。

使用提供的标识值和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 。

使用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 。

使用提供的标识，累积和组合功能对此流的元素执行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 。

对此流的元素执行mutable reduction操作。 可变减少是其中减少的值是可变结果容器（例如ArrayList ，并且通过更新结果的状态而不是通过替换结果来合并元素。 这产生的结果相当于： 
 R result = supplier.get(); for (T element : this stream) accumulator.accept(result, element); return result;

与reduce(Object, BinaryOperator)类似 ，可以并行化collect操作，而无需额外的同步。

这是一个terminal operation 。

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

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

这是一个terminal operation 。

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

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

这是一个terminal operation 。

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

这是一个terminal operation 。

返回此流中元素的数量。 这是reduction的特例 ，相当于： 
 return mapToLong(e -> 1L).sum();

这是一个terminal operation 。

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

这是一个short-circuiting terminal operation 。

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

这是一个short-circuiting terminal operation 。

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

这是short-circuiting terminal operation 。

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

这是一个short-circuiting terminal operation 。

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

这是一个short-circuiting terminal operation 。

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

返回 Stream的构建器。 返回空序列 Stream 。 返回包含单个元素的顺序 Stream 。 返回包含单个元素的顺序 Stream （如果为非null），否则返回空 Stream 。 返回其元素为指定值的顺序有序流。 返回有序无限连续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用于随后的元件。 对于任何给定元素，可以在库选择的任何线程中执行操作。

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

Stream.iterate应该生成与相应的for循环生成的元素序列相同的元素： 

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

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

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

返回无限顺序无序流，其中每个元素由提供的Supplier生成。 这适用于生成恒定流，随机元素流等。 创建一个延迟连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。 如果两个输入流都是有序的，则对所得到的流进行排序，如果任一输入流是并行的，则对其进行并行。 关闭结果流时，将调用两个输入流的关闭处理程序。

此方法对两个输入流进行操作，并将每个流绑定到其源。 结果，对输入流源的后续修改可能不会反映在级联流结果中。

嵌套类  
变量和类型 接口 描述
static interface  Stream.Builder<T>
适用于 Stream可变构建器。
所有方法  静态方法  实例方法 抽象方法  Default Methods 
变量和类型 方法 描述
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 （如果为非null），否则返回空 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函数分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。