IntStream

allMatch

boolean allMatch (IntPredicate predicate)

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

这是一个 short-circuiting terminal operation 。

anyMatch

boolean anyMatch (IntPredicate predicate)

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

这是一个 short-circuiting terminal operation 。

asDoubleStream

DoubleStream asDoubleStream ()

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

这是一个 intermediate operation 。

asLongStream

LongStream asLongStream ()

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

这是一个 intermediate operation 。

average

OptionalDouble average ()

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

这是一个 terminal operation 。

boxed

Stream<Integer> boxed ()

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

这是一个 intermediate operation 。

builder

IntStream.Builder builder ()

返回 IntStream的构建器。

collect

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

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

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

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

这是一个 terminal operation 。

concat

IntStream concat (IntStream a, 
                IntStream b)

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

count

long count ()

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

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

这是一个 terminal operation 。

distinct

IntStream distinct ()

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

这是一个 stateful intermediate operation 。

empty

IntStream empty ()

返回一个空的顺序 IntStream 。

filter

IntStream filter (IntPredicate predicate)

返回包含此流中与给定谓词相匹配的元素的流。

这是一个 intermediate operation 。

findAny

OptionalInt findAny ()

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

这是一个 short-circuiting terminal operation 。

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

findFirst

OptionalInt findFirst ()

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

这是一个 short-circuiting terminal operation 。

flatMap

IntStream flatMap (IntFunction<? extends IntStream> mapper)

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

这是一个 intermediate operation 。

forEach

void forEach (IntConsumer action)

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

这是一个 terminal operation 。

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

forEachOrdered

void forEachOrdered (IntConsumer action)

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

这是一个 terminal operation 。

generate

IntStream generate (IntSupplier s)

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

iterate

IntStream iterate (int seed, 
                IntUnaryOperator f)

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

第一元件（位置0在） IntStream将是提供seed 。 对于n > 0 ，位置n处的元素将是将函数f应用于位置n - 1上的元素的n - 1 。

iterator

PrimitiveIterator.OfInt iterator ()

返回此流的元素的迭代器。

这是一个 terminal operation 。

limit

IntStream limit (long maxSize)

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

这是一个 short-circuiting stateful intermediate operation 。

map

IntStream map (IntUnaryOperator mapper)

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

这是一个 intermediate operation 。

mapToDouble

DoubleStream mapToDouble (IntToDoubleFunction mapper)

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

这是一个 intermediate operation 。

mapToLong

LongStream mapToLong (IntToLongFunction mapper)

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

这是一个 intermediate operation 。

mapToObj

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

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

这是一个 intermediate operation 。

max

OptionalInt max ()

返回描述此流的最大元素的OptionalInt ，如果此流为空，则返回一个空的可选项。 这是reduction的特例 ，相当于：

return reduce(Integer::max);
 

这是一个 terminal operation 。

min

OptionalInt min ()

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

return reduce(Integer::min);
 

这是一个 terminal operation 。

noneMatch

boolean noneMatch (IntPredicate predicate)

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

这是一个 short-circuiting terminal operation 。

of

IntStream of (int t)

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

of

IntStream of (int... values)

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

parallel

IntStream parallel ()

返回平行的等效流。 可能会返回自己，因为流已经是平行的，或者因为基础流状态被修改为平行。

这是一个 intermediate operation 。

peek

IntStream peek (IntConsumer action)

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

这是一个 intermediate operation 。

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

range

IntStream range (int startInclusive, 
                int endExclusive)

返回从 startInclusive （含）到 endExclusive （不包括）的顺序排列的 IntStream ，增量步骤为 1 。

rangeClosed

IntStream rangeClosed (int startInclusive, 
                int endInclusive)

返回从 startInclusive （含）至 endInclusive （含）的顺序排列的 IntStream ，增量为 1 。

reduce

OptionalInt reduce (IntBinaryOperator op)

使用associative累加函数对此流的元素执行reduction ，并返回描述缩减值的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函数必须是 associative函数。

这是一个 terminal operation 。

reduce

int reduce (int identity, 
                IntBinaryOperator op)

使用提供的标识值和associative累加函数对此流的元素执行reduction ，并返回缩小的值。 这相当于：

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

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

这是一个 terminal operation 。

sequential

IntStream sequential ()

返回顺序的等效流。 可能会返回自己，因为流已经是顺序的，或者因为基础流状态被修改为顺序的。

这是一个 intermediate operation 。

skip

IntStream skip (long n)

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

这是一个 stateful intermediate operation 。

sorted

IntStream sorted ()

以排序顺序返回由此流的元素组成的流。

这是一个 stateful intermediate operation 。

spliterator

Spliterator.OfInt spliterator ()

返回此流的元素的分割器。

这是一个 terminal operation 。

sum

int sum ()

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

return reduce(0, Integer::sum);
 

这是一个 terminal operation 。

summaryStatistics

IntSummaryStatistics summaryStatistics ()

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

这是一个 terminal operation 。

toArray

int[] toArray ()

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

这是一个 terminal operation 。