模块 java.base

包 java.util.stream

接口 IntStream

所有父级接口：

AutoCloseable , BaseStream<Integer,IntStream>

public interface IntStream extends BaseStream <Integer ,IntStream >
      

支持顺序和并行聚合操作的原始 int 值元素序列。这是 Stream 的 int 原始特化。

以下示例说明了使用 Stream 和 IntStream 的聚合操作，计算红色小部件的权重之和：

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

有关流、流操作、流管道和并行性的其他规范，请参阅 Stream 的类文档和 java.util.stream 的包文档。

自从：

1.8

参见：

• Stream
• java.util.stream

内部类总结

内部类

修饰符和类型	接口	描述
static interface	IntStream.Builder	IntStream 的可变构建器。
static interface	IntStream.IntMapMultiConsumer	表示接受 int 值参数和 IntConsumer 且不返回任何结果的操作。

方法总结

修饰符和类型	方法	描述
boolean	allMatch(IntPredicate predicate)	返回此流的所有元素是否与提供的谓词匹配。
boolean	anyMatch(IntPredicate predicate)	返回此流的任何元素是否与提供的谓词匹配。
DoubleStream	asDoubleStream()	返回由该流的元素组成的 DoubleStream，转换为 double。
LongStream	asLongStream()	返回由该流的元素组成的 LongStream，转换为 long。
OptionalDouble	average()	返回一个 OptionalDouble 描述该流元素的算术平均值，或者如果该流为空则返回一个空的可选值。
Stream<Integer>	boxed()	返回一个 Stream 由该流的元素组成，每个元素装箱到一个 Integer 。
static IntStream.Builder	builder()	返回 IntStream 的构建器。
<R> R	collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,R> combiner)	对此流的元素执行 可变减少 操作。
static IntStream	concat(IntStream a, IntStream b)	创建一个惰性串联流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
long	count()	返回此流中元素的计数。
IntStream	distinct()	返回由该流的不同元素组成的流。
default IntStream	dropWhile(IntPredicate predicate)	如果此流是有序的，则返回一个流，该流由删除与给定谓词匹配的元素的最长前缀后的此流的剩余元素组成。
static IntStream	empty()	返回一个空的顺序 IntStream 。
IntStream	filter(IntPredicate predicate)	返回一个流，该流由与给定谓词匹配的此流的元素组成。
OptionalInt	findAny()	返回描述流中某些元素的 OptionalInt ，如果流为空，则返回空的 OptionalInt。
OptionalInt	findFirst()	返回描述此流的第一个元素的 OptionalInt ，如果流为空，则返回空的 OptionalInt。
IntStream	flatMap(IntFunction<? extends IntStream> mapper)	返回一个流，该流由将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容组成的结果。
void	forEach(IntConsumer action)	对此流的每个元素执行一个操作。
void	forEachOrdered(IntConsumer action)	对此流的每个元素执行一个操作，保证每个元素都按照流的遇到顺序处理，这些流具有定义的遇到顺序。
static IntStream	generate(IntSupplier s)	返回无限顺序无序流，其中每个元素都由提供的 IntSupplier 生成。
static IntStream	iterate(int seed, IntPredicate hasNext, IntUnaryOperator next)	返回由给定的 next 函数迭代应用到初始元素而产生的顺序有序的 IntStream，条件是满足给定的 hasNext 谓词。
static IntStream	iterate(int seed, IntUnaryOperator f)	返回由函数 f 迭代应用到初始元素 seed 产生的无限顺序有序 IntStream，产生由 seed、f(seed)、f(f(seed)) 等组成的 Stream。
IntStream	limit(long maxSize)	返回由该流的元素组成的流，截断后的长度不超过 maxSize。
IntStream	map(IntUnaryOperator mapper)	返回一个流，该流由将给定函数应用于此流的元素的结果组成。
default IntStream	mapMulti(IntStream.IntMapMultiConsumer mapper)	返回一个流，该流由用多个元素（特别是零个或多个元素）替换此流的每个元素的结果组成。
DoubleStream	mapToDouble(IntToDoubleFunction mapper)	返回一个 DoubleStream，由将给定函数应用于此流的元素的结果组成。
LongStream	mapToLong(IntToLongFunction mapper)	返回一个 LongStream，由将给定函数应用于此流的元素的结果组成。
<U> Stream<U>	mapToObj(IntFunction<? extends U> mapper)	返回一个对象值 Stream，由将给定函数应用于此流的元素的结果组成。
OptionalInt	max()	返回一个 OptionalInt 描述这个流的最大元素，或者如果这个流是空的则返回一个空的可选值。
OptionalInt	min()	返回一个 OptionalInt 描述这个流的最小元素，或者如果这个流是空的则返回一个空的可选值。
boolean	noneMatch(IntPredicate predicate)	返回此流中是否没有元素与提供的谓词匹配。
static IntStream	of(int t)	返回包含单个元素的顺序 IntStream。
static IntStream	of(int... values)	返回其元素为指定值的顺序有序流。
IntStream	peek(IntConsumer action)	返回一个由该流的元素组成的流，当从结果流中消耗元素时，还会对每个元素执行提供的操作。
static IntStream	range(int startInclusive, int endExclusive)	通过 1 的增量步返回从 startInclusive（含）到 endExclusive（不含）的顺序有序 IntStream。
static IntStream	rangeClosed(int startInclusive, int endInclusive)	通过 1 的增量步返回从 startInclusive（含）到 endInclusive（含）的顺序有序 IntStream。
int	reduce(int identity, IntBinaryOperator op)	使用提供的标识值和 联想的 累加函数对此流的元素执行 减少，并返回减少的值。
OptionalInt	reduce(IntBinaryOperator op)	使用 联想的 累加函数对此流的元素执行 减少，并返回描述减少值的 OptionalInt（如果有）。
IntStream	skip(long n)	在丢弃流的前 n 个元素后，返回由该流的剩余元素组成的流。
IntStream	sorted()	返回一个流，该流由按排序顺序排列的此流的元素组成。
int	sum()	返回此流中元素的总和。
IntSummaryStatistics	summaryStatistics()	返回一个 IntSummaryStatistics 描述有关此流元素的各种摘要数据。
default IntStream	takeWhile(IntPredicate predicate)	如果此流是有序的，则返回一个流，该流由从此流中获取的与给定谓词匹配的元素的最长前缀组成。
int[]	toArray()	返回包含此流的元素的数组。

在接口 java.util.stream.BaseStream 中声明的方法

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

方法详情

filter

IntStream  filter(IntPredicate  predicate)
            

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

这是一个 中间操作 。

参数：

predicate - 一个 不干扰 , 无国籍的 谓词应用于每个元素以确定是否应包含它

返回：

新流

map

IntStream  map(IntUnaryOperator  mapper)
            

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

这是一个 中间操作 。

参数：

mapper - 一个 不干扰 , 无国籍的 函数应用于每个元素

返回：

新流

mapToObj

<U> Stream <U> mapToObj(IntFunction <? extends U> mapper)
            

返回一个对象值 Stream，由将给定函数应用于此流的元素的结果组成。

这是一个 中间操作 。

类型参数：

U - 新流的元素类型

参数：

mapper - 一个 不干扰 , 无国籍的 函数应用于每个元素

返回：

新流

mapToLong

LongStream  mapToLong(IntToLongFunction  mapper)
            

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

这是一个 中间操作 。

参数：

mapper - 一个 不干扰 , 无国籍的 函数应用于每个元素

返回：

新流

mapToDouble

DoubleStream  mapToDouble(IntToDoubleFunction  mapper)
            

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

这是一个 中间操作 。

参数：

mapper - 一个 不干扰 , 无国籍的 函数应用于每个元素

返回：

新流

flatMap

IntStream  flatMap(IntFunction <? extends IntStream > mapper)
            

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

这是一个 中间操作 。

参数：

mapper - 一个 不干扰 、 无国籍的 函数应用于每个产生 IntStream 新值的元素

返回：

新流

参见：

• Stream.flatMap(Function)

mapMulti

default IntStream  mapMulti(IntStream.IntMapMultiConsumer  mapper)
            

返回一个流，该流由用多个元素（特别是零个或多个元素）替换此流的每个元素的结果组成。通过将提供的映射函数与接受替换元素的consumer参数一起应用于每个元素来执行替换。映射函数零次或多次调用消费者以提供替换元素。

这是一个 中间操作 。

如果 consumer 参数在其映射函数的应用范围之外使用，则结果未定义。

实现要求：

默认实现在此流上调用 flatMap ，传递一个行为如下的函数。首先，它使用 IntConsumer 调用映射器函数，将替换元素累积到新创建的内部缓冲区中。当映射器函数返回时，它会从内部缓冲区创建一个IntStream。最后，它将这个流返回给 flatMap 。

参数：

mapper - 生成替换元素的 不干扰、无国籍的 函数

返回：

新流

自从：

16

参见：

• Stream.mapMulti

distinct

IntStream  distinct()
            

返回由该流的不同元素组成的流。

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

返回：

新流

sorted

IntStream  sorted()
            

返回一个流，该流由按排序顺序排列的此流的元素组成。

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

返回：

新流

peek

IntStream  peek(IntConsumer  action)
            

返回一个由该流的元素组成的流，当从结果流中消耗元素时，还会对每个元素执行提供的操作。

这是一个 中间操作 。

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

API 注意：

此方法的存在主要是为了支持调试，您希望在元素流过管道中的某个点时查看元素：

   IntStream.of(1, 2, 3, 4)
     .filter(e -> e > 2)
     .peek(e -> System.out.println("Filtered value: " + e))
     .map(e -> e * e)
     .peek(e -> System.out.println("Mapped value: " + e))
     .sum();
  

在流实现能够优化部分或所有元素的生产的情况下（例如使用像 findFirst 这样的短路操作，或者在 count() 中描述的示例中），将不会为这些元素调用操作。

参数：

action - 一个 不干扰 在元素从流中消耗时执行的操作

返回：

新流

limit

IntStream  limit(long maxSize)
            

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

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

API 注意：

虽然 limit() 通常是顺序流管道上的廉价操作，但它在有序并行管道上可能非常昂贵，尤其是对于 maxSize 的大值，因为 limit(n) 不仅限于返回任何 n 元素，而且返回遇到顺序中的 first n 元素。如果您的情况的语义允许，使用无序流源（例如 generate(IntSupplier) ）或使用 BaseStream.unordered() 删除排序约束可能会导致并行管道中的 limit() 显着加速。如果需要与遇到顺序保持一致，并且在并行管道中使用 limit() 时性能或内存利用率不佳，则切换到使用 BaseStream.sequential() 的顺序执行可能会提高性能。

参数：

maxSize - 流应限制为的元素数

返回：

新流

抛出：

IllegalArgumentException - 如果 maxSize 为负

skip

IntStream  skip(long n)
            

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

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

API 注意：

虽然 skip() 通常是顺序流管道上的廉价操作，但它在有序并行管道上可能非常昂贵，尤其是对于较大的 n 值，因为 skip(n) 不仅要跳过任何 n 元素，还要跳过遇到顺序中的 first n 元素。如果您的情况语义允许，使用无序流源（例如 generate(IntSupplier) ）或使用 BaseStream.unordered() 删除排序约束可能会导致并行管道中的 skip() 显着加速。如果需要与遇到顺序保持一致，并且在并行管道中使用 skip() 时性能或内存利用率不佳，则切换到使用 BaseStream.sequential() 的顺序执行可能会提高性能。

参数：

n - 要跳过的前导元素数

返回：

新流

抛出：

IllegalArgumentException - 如果 n 为负

takeWhile

default IntStream  takeWhile(IntPredicate  predicate)
            

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

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

如果这个流是无序的，并且这个流的一些（但不是全部）元素匹配给定的谓词，那么这个操作的行为是不确定的；可以自由获取匹配元素的任何子集（包括空集）。

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

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

API 注意：

虽然 takeWhile() 通常是顺序流管道上的廉价操作，但它在有序并行管道上可能非常昂贵，因为该操作被限制为不仅返回任何有效前缀，而且返回遇到顺序中元素的最长前缀。如果您的情况的语义允许，使用无序流源（例如 generate(IntSupplier) ）或使用 BaseStream.unordered() 删除排序约束可能会导致并行管道中的 takeWhile() 显着加速。如果需要与遇到顺序保持一致，并且在并行管道中使用 takeWhile() 时性能或内存利用率不佳，则切换到使用 BaseStream.sequential() 的顺序执行可能会提高性能。

实现要求：

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

参数：

predicate - 一个 不干扰 , 无国籍的 谓词应用于元素以确定元素的最长前缀。

返回：

新流

自从：

9

dropWhile

default IntStream  dropWhile(IntPredicate  predicate)
            

如果此流是有序的，则返回一个流，该流由删除与给定谓词匹配的元素的最长前缀后的此流的剩余元素组成。否则，如果此流是无序的，则在删除与给定谓词匹配的元素子集后，返回由此流的剩余元素组成的流。

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

如果这个流是无序的，并且这个流的一些（但不是全部）元素匹配给定的谓词，那么这个操作的行为是不确定的；可以随意删除匹配元素的任何子集（包括空集）。

独立于此流是有序的还是无序的如果此流的所有元素都匹配给定的谓词，则此操作删除所有元素（结果是一个空流），或者如果流中没有元素匹配给定的谓词则不删除任何元素（结果与输入相同）。

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

API 注意：

虽然 dropWhile() 通常是顺序流管道上的廉价操作，但它在有序并行管道上可能非常昂贵，因为操作被限制为不仅返回任何有效前缀，而且返回遇到顺序中元素的最长前缀。如果您的情况的语义允许，使用无序流源（例如 generate(IntSupplier) ）或使用 BaseStream.unordered() 删除排序约束可能会导致并行管道中的 dropWhile() 显着加速。如果需要与遇到顺序保持一致，并且在并行管道中使用 dropWhile() 时性能或内存利用率不佳，则切换到使用 BaseStream.sequential() 的顺序执行可能会提高性能。

实现要求：

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

参数：

predicate - 一个 不干扰 , 无国籍的 谓词应用于元素以确定元素的最长前缀。

返回：

新流

自从：

9

forEach

void forEach(IntConsumer  action)
            

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

这是一个 终端操作 。

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

参数：

action - 对元素执行的 不干扰 操作

forEachOrdered

void forEachOrdered(IntConsumer  action)
            

对此流的每个元素执行一个操作，保证每个元素都按照流的遇到顺序处理，这些流具有定义的遇到顺序。

这是一个 终端操作 。

参数：

action - 对元素执行的 不干扰 操作

参见：

• forEach(IntConsumer)

toArray

int[] toArray()
            

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

这是一个 终端操作 。

返回：

包含此流的元素的数组

reduce

int reduce(int identity, IntBinaryOperator  op)
            

使用提供的标识值和 联想的 累加函数对此流的元素执行 减少，并返回减少的值。这等同于：

   int result = identity;
   for (int element : this stream)
     result = accumulator.applyAsInt(result, element)
   return result;
  

但不限于按顺序执行。

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

这是一个 终端操作 。

API 注意：

Sum、min 和 max 都是可以使用此方法表示的归约的特例。例如，对流求和可以表示为：

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

或更简洁：

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

虽然与简单地在循环中改变运行总数相比，这似乎是一种执行聚合的更迂回的方式，但缩减操作更优雅地并行化，不需要额外的同步，并且大大降低了数据竞争的风险。

参数：

identity - 累积函数的标识值

op - 一个 联想的 、 不干扰 、 无国籍的 函数用于组合两个值

返回：

减少的结果

参见：

• sum()
• min()
• max()
• average()

reduce

OptionalInt  reduce(IntBinaryOperator  op)
            

使用 联想的 累加函数对此流的元素执行 减少，并返回描述减少值的 OptionalInt（如果有）。这等效于：

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

但不受顺序执行的限制。

accumulator 函数必须是 联想的 函数。

这是一个 终端操作 。

参数：

op - 一个 联想的 、 不干扰 、 无国籍的 函数用于组合两个值

返回：

减少的结果

参见：

• reduce(int, IntBinaryOperator)

collect

<R> R collect(Supplier <R> supplier, ObjIntConsumer <R> accumulator, BiConsumer <R,R> combiner)
            

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

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

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

这是一个 终端操作 。

类型参数：

R - 可变结果容器的类型

参数：

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

accumulator - 一个 联想的 、 不干扰 、 无国籍的 必须将元素折叠到结果容器中的函数。

combiner - 一个 联想的 、 不干扰 、 无国籍的 函数接受两个部分结果容器并合并它们，它必须与累加器函数兼容。 combiner 函数必须将第二个结果容器中的元素折叠到第一个结果容器中。

返回：

减少的结果

参见：

• Stream.collect(Supplier, BiConsumer, BiConsumer)

sum

int sum()
            

返回此流中元素的总和。这是 减少 的特例，相当于：

   return reduce(0, Integer::sum);
  

这是一个 终端操作 。

返回：

此流中元素的总和

min

OptionalInt  min()
            

返回一个 OptionalInt 描述这个流的最小元素，或者如果这个流是空的则返回一个空的可选值。这是 减少 的特例，相当于：

   return reduce(Integer::min);
  

这是一个 终端操作 。

返回：

包含此流的最小元素的 OptionalInt，如果流为空，则为空的 OptionalInt

max

OptionalInt  max()
            

返回一个 OptionalInt 描述这个流的最大元素，或者如果这个流是空的则返回一个空的可选值。这是 减少 的特例，相当于：

   return reduce(Integer::max);
  

这是一个 终端操作 。

返回：

包含此流的最大元素的 OptionalInt，如果流为空，则为空的 OptionalInt

count

long count()
            

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

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

这是一个 终端操作 。

API 注意：

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

   IntStream s = IntStream.of(1, 2, 3, 4);
   long count = s.peek(System.out::println).count();
  

流源覆盖的元素数量是已知的，中间操作 peek 不会从流中注入或移除元素（对于 flatMap 或 filter 操作可能就是这种情况）。因此计数为 4 并且不需要执行管道，作为副作用，打印出元素。

返回：

此流中的元素数

average

OptionalDouble  average()
            

返回一个 OptionalDouble 描述该流元素的算术平均值，或者如果该流为空则返回一个空的可选值。这是 减少 的特例。

这是一个 终端操作 。

返回：

包含此流的平均元素的 OptionalDouble，如果流为空，则为空可选

summaryStatistics

IntSummaryStatistics  summaryStatistics()
            

返回一个 IntSummaryStatistics 描述有关此流元素的各种摘要数据。这是 减少 的特例。

这是一个 终端操作 。

返回：

一个 IntSummaryStatistics 描述有关此流元素的各种摘要数据

anyMatch

boolean anyMatch(IntPredicate  predicate)
            

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

这是一个 短路端子操作 。

API 注意：

此方法评估流元素上谓词的 existential quantification（对于某些 x P(x)）。

参数：

predicate - 一个 不干扰 , 无国籍的 谓词应用于此流的元素

返回：

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

allMatch

boolean allMatch(IntPredicate  predicate)
            

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

这是一个 短路端子操作 。

API 注意：

此方法评估流元素上谓词的universal quantification（对于所有 x P(x)）。如果流为空，则称量化为 vacuously satisfied 并且始终为 true（与 P(x) 无关）。

参数：

predicate - 一个 不干扰 , 无国籍的 谓词应用于此流的元素

返回：

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

noneMatch

boolean noneMatch(IntPredicate  predicate)
            

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

这是一个 短路端子操作 。

API 注意：

此方法对流的元素（对于所有 x ~P(x)）计算否定谓词的 universal quantification。如果流为空，则称量化是无意义地满足的并且始终为 true ，而不管 P(x)。

参数：

predicate - 一个 不干扰 , 无国籍的 谓词应用于此流的元素

返回：

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

findFirst

OptionalInt  findFirst()
            

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

这是一个 短路端子操作 。

返回：

一个 OptionalInt 描述这个流的第一个元素，或者一个空的 OptionalInt 如果流是空的

findAny

OptionalInt  findAny()
            

返回描述流中某些元素的 OptionalInt ，如果流为空，则返回空的 OptionalInt。

这是一个 短路端子操作 。

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

返回：

一个 OptionalInt 描述这个流的一些元素，或者一个空的 OptionalInt 如果流是空的

参见：

• findFirst()

asLongStream

LongStream  asLongStream()
            

返回由该流的元素组成的 LongStream，转换为 long。

这是一个 中间操作 。

返回：

一个 LongStream 由这个流的元素组成，转换为 long

asDoubleStream

DoubleStream  asDoubleStream()
            

返回由该流的元素组成的 DoubleStream，转换为 double。

这是一个 中间操作 。

返回：

一个 DoubleStream 由这个流的元素组成，转换为 double

boxed

Stream <Integer > boxed()
            

返回一个 Stream 由该流的元素组成，每个元素装箱到一个 Integer 。

这是一个 中间操作 。

返回：

一个 Stream 与此流的元素一致，每个装箱到一个 Integer

builder

static IntStream.Builder  builder()
            

返回 IntStream 的构建器。

返回：

流生成器

empty

static IntStream  empty()
            

返回一个空的顺序 IntStream 。

返回：

一个空的顺序流

of

static IntStream  of(int t)
            

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

参数：

t - 单个元素

返回：

单例顺序流

of

static IntStream  of(int... values)
            

返回其元素为指定值的顺序有序流。

参数：

values - 新流的元素

返回：

新流

iterate

static IntStream  iterate(int seed, IntUnaryOperator  f)
            

返回由函数 f 迭代应用到初始元素 seed 产生的无限顺序有序 IntStream，产生由 seed、f(seed)、f(f(seed)) 等组成的 Stream。

IntStream 中的第一个元素（位置 0 ）将是提供的 seed 。对于 n > 0 ，位置 n 的元素将是将函数 f 应用于位置 n - 1 的元素的结果。

对一个元素应用 f 的动作 发生之前 对后续元素应用 f 的动作。对于任何给定的元素，操作可以在库选择的任何线程中执行。

参数：

seed - 初始元素

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

返回：

一个新的顺序 IntStream

iterate

static IntStream  iterate(int seed, IntPredicate  hasNext, IntUnaryOperator  next)
            

返回由给定的 next 函数迭代应用到初始元素而产生的顺序有序的 IntStream，条件是满足给定的 hasNext 谓词。一旦 hasNext 谓词返回 false，流就会终止。

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

   for (int index=seed; hasNext.test(index); index = next.applyAsInt(index)) {
     ...
   }
  

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

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

参数：

seed - 初始元素

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

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

返回：

一个新的顺序 IntStream

自从：

9

generate

static IntStream  generate(IntSupplier  s)
            

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

参数：

s - 生成元素的 IntSupplier

返回：

一个新的无限顺序无序IntStream

range

static IntStream  range(int startInclusive, int endExclusive)
            

通过 1 的增量步返回从 startInclusive（含）到 endExclusive（不含）的顺序有序 IntStream。

API 注意：

可以使用 for 循环按如下方式依次生成递增值的等效序列：

   for (int i = startInclusive; i < endExclusive ; i++) { ... }
  

参数：

startInclusive -（含）初始值

endExclusive - 独家上限

返回：

int 元素范围的顺序 IntStream

rangeClosed

static IntStream  rangeClosed(int startInclusive, int endInclusive)
            

通过 1 的增量步返回从 startInclusive（含）到 endInclusive（含）的顺序有序 IntStream。

API 注意：

可以使用 for 循环按如下方式依次生成递增值的等效序列：

   for (int i = startInclusive; i <= endInclusive ; i++) { ... }
  

参数：

startInclusive -（含）初始值

endInclusive - 包含上限

返回：

int 元素范围的顺序 IntStream

concat

static IntStream  concat(IntStream  a, IntStream  b)
            

创建一个惰性串联流，其元素是第一个流的所有元素，后跟第二个流的所有元素。如果两个输入流都是有序的，则结果流是有序的，如果其中一个输入流是并行的，则结果流是并行的。当结果流关闭时，将调用两个输入流的关闭处理程序。

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

API 注意：

为了保留优化机会，此方法将每个流绑定到其源并仅接受两个流作为参数。例如，如果知道每个输入流源的确切大小，则可以计算连接流源的确切大小。要在不绑定或不嵌套调用此方法的情况下连接更多流，请尝试使用身份函数创建流流和平面映射流，例如：

   IntStream concat = Stream.of(s1, s2, s3, s4).flatMapToInt(s -> s);
  

实现注意事项：

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

参数：

a - 第一个流

b - 第二个流

返回：

两个输入流的连接