IntStream (Java Platform SE 8 )

All Superinterfaces:

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包文档类文件流操作，流管道，和并行性。
从以下版本开始：

一点八

另请参见：

Stream， java.util.stream

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`IntStream.Builder` 一个 `IntStream`易变的建设者。

方法摘要

所有方法静态方法接口方法抽象方法 Default Methods
Modifier and Type	Method and Description
`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)` 执行该流的元素 mutable reduction操作。
`static IntStream`	`concat(IntStream a, IntStream b)` 创建一个懒洋洋的级联流的元素的所有元素的第一流通过第二个流的元素。
`long`	`count()` 返回此流中元素的计数。
`IntStream`	`distinct()` 返回由该流的不同元素组成的流。
`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, IntUnaryOperator f)` 返回一个无穷序列有序 `IntStream`由最初的一元 `seed`函数的 `f`迭代应用产生的，产生一个由 `seed`， `f(seed)`， `f(f(seed))` `Stream`，等。
`PrimitiveIterator.OfInt`	`iterator()` 返回此流的元素的迭代器。
`IntStream`	`limit(long maxSize)` 返回一个包含该流的元素流，截断长度不超过 `maxSize`。
`IntStream`	`map(IntUnaryOperator 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... values)` 返回一个元素为指定值的顺序排列的流。
`static IntStream`	`of(int t)` 返回一个包含一个元素的顺序 `IntStream`。
`IntStream`	`parallel()` 返回一个并行的等效流。
`IntStream`	`peek(IntConsumer action)` 返回由该流的元素组成的流，并在所提供的流中执行所提供的每个元素上的动作。
`static IntStream`	`range(int startInclusive, int endExclusive)` 返回一个有序 `IntStream`从 `startInclusive`（含）至 `endExclusive`（独家）由 `1`增量步。
`static IntStream`	`rangeClosed(int startInclusive, int endInclusive)` 返回一个有序 `IntStream`从 `startInclusive`（含）至 `endInclusive`（含）的 `1`增量步。
`OptionalInt`	`reduce(IntBinaryOperator op)` 对这一 reduction流元素，使用 associative累积函数，并返回一个 `OptionalInt`描述价值减少，如果任何。
`int`	`reduce(int identity, IntBinaryOperator op)` 对这一 reduction流元素，使用提供的价值认同和 associative累积函数，返回值减少。
`IntStream`	`sequential()` 返回一个连续的等效流。
`IntStream`	`skip(long n)` 返回一个包含此流的其余部分丢弃的流的第一 `n`元素后流。
`IntStream`	`sorted()` 返回按排序顺序由该流的元素组成的流。
`Spliterator.OfInt`	`spliterator()` 返回一个对该流的元素spliterator。
`int`	`sum()` 返回此流中元素的和。
`IntSummaryStatistics`	`summaryStatistics()` 返回一个 `IntSummaryStatistics`描述该流的元素的各种汇总数据。
`int[]`	`toArray()` 返回包含此流元素的数组。

Methods inherited from interface java.util.stream.BaseStream
close, isParallel, onClose, unordered

- 方法详细信息
  - filter
```
IntStream filter(IntPredicate predicate)
```
    返回由该流的元素组成的流，该元素与给定的谓词匹配。
    这是一个intermediate operation。
    
    参数
    
    predicate - non-interfering， stateless谓词应用到每个元素以确定它是否应该包括
    
    结果
    
    新的流
  - map
```
IntStream map(IntUnaryOperator mapper)
```
    返回一个流，包括将给定函数应用到该流元素的结果。
    这是一个intermediate operation。
    
    参数
    
    mapper - non-interfering， stateless功能适用于每一个元素
    
    结果
    
    新的流
  - mapToObj
```
<U> Stream<U> mapToObj(IntFunction<? extends U> mapper)
```
    返回一个对象的值 Stream组成的应用给出的函数的流元素的结果。
    这是一个 intermediate operation。
    
    参数类型
    
    U -新的流元素类型
    
    参数
    
    mapper - non-interfering， stateless功能适用于每一个元素
    
    结果
    
    新的流
  - mapToLong
```
LongStream mapToLong(IntToLongFunction mapper)
```
    返回一个包含应用给定的功能，该流的元素的结果 LongStream。
    这是一个intermediate operation。
    
    参数
    
    mapper - non-interfering， stateless功能适用于每一个元素
    
    结果
    
    新的流
  - mapToDouble
```
DoubleStream mapToDouble(IntToDoubleFunction mapper)
```
    返回一个包含应用给定的功能，该流的元素的结果 DoubleStream。
    这是一个intermediate operation。
    
    参数
    
    mapper - non-interfering， stateless功能适用于每一个元素
    
    结果
    
    新的流
  - flatMap
```
IntStream flatMap(IntFunction<? extends IntStream> mapper)
```
    返回由将所提供的映射函数应用到每个元素的映射流的内容替换此流的每个元素的结果的结果流。每个映射流 closed后其内容被放置到该流。（如果一个映射的流 null空流使用，而不是
    这是一个intermediate operation。
    。）
    
    参数
    
    mapper - non-interfering， stateless功能适用于每一个元素产生新价值观的一个 IntStream
    
    结果
    
    新的流
    
    另请参见：
    
    Stream.flatMap(Function)
  - distinct
```
IntStream distinct()
```
    返回由该流的不同元素组成的流。
    这是一个stateful intermediate operation。
    
    结果
    
    新的流
  - sorted
```
IntStream sorted()
```
    返回按排序顺序由该流的元素组成的流。
    这是一个stateful intermediate operation。
    
    结果
    
    新的流
  - peek
```
IntStream peek(IntConsumer action)
```
    返回由该流的元素组成的流，并在所提供的流中执行所提供的每个元素上的动作。
    这是一个intermediate operation。
    
    对于并行流管道，操作可以在任何时间和任何线程中调用元素，由上游操作提供。如果操作修改共享状态，则负责提供所需的同步。
    API Note:
    这种方法存在的主要支持调试，你想看到的元素作为他们流过管道中某一点的地方：
    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();
    参数
    
    action - non-interfering动作执行的元素作为他们的消费从流
    
    结果
    
    新的流
  - limit
```
IntStream limit(long maxSize)
```
    返回一个包含该流的元素流，截断长度不超过 maxSize。
    这是一个short-circuiting stateful intermediate operation。
    
    API Note:
    
    而 limit()一般顺序流管道便宜的操作，它可以在有序的平行管道是相当昂贵的，尤其是对 maxSize大的值，因为 limit(n)约束还不是任何n个元素，而第n个元素在遇到订单。使用一个无序的流源（如 generate(IntSupplier)）或拆卸顺序约束与 BaseStream.unordered()可能导致并联管道 limit()显著加速，如果你的情况允许语义。如果遇到顺序一致性是必需的，和你所经历的可怜的性能或内存利用并行管道 limit()，切顺序执行 sequential()可以提高性能。
    
    参数
    
    maxSize -流应限制元素的数量
    
    结果
    
    新的流
    
    异常
    
    IllegalArgumentException -如果 maxSize是负的
  - skip
```
IntStream skip(long n)
```
    返回一个包含此流的其余部分丢弃的流的第一 n元素后流。如果这个流包含少于 n元素然后将返回空流。
    这是一个stateful intermediate operation。
    
    API Note:
    
    而 skip()一般顺序流管道便宜的操作，它可以在有序的平行管道是相当昂贵的，尤其是对 n大的值，因为 skip(n)约束跳过不是任何n个元素，而第n个元素在遇到订单。使用一个无序的流源（如 generate(IntSupplier)）或拆卸顺序约束与 BaseStream.unordered()可能导致并联管道 skip()显著加速，如果你的情况允许语义。如果遇到顺序一致性是必需的，和你所经历的可怜的性能或内存利用并行管道 skip()，切顺序执行 sequential()可以提高性能。
    
    参数
    
    n -领先的元素数跳过
    
    结果
    
    新的流
    
    异常
    
    IllegalArgumentException -如果 n是负的
  - forEach
```
void forEach(IntConsumer action)
```
    对该流的每个元素执行一个动作。
    这是一个terminal operation。
    
    对于并行流管道，这种操作不保证尊重流的遇到顺序，这样做会牺牲并行的利益。对于任何给定的元素，动作可以在任何时间和任何线程中执行库所选择的任何线程上执行。如果操作访问共享状态，则负责提供所需的同步。
    
    参数
    
    action - non-interfering行动对元件进行
  - forEachOrdered
```
void forEachOrdered(IntConsumer action)
```
    对该流的每个元素执行一个动作，保证每个元素在遇到有定义的遇到顺序的流中处理。
    这是一个terminal operation。
    
    参数
    
    action - non-interfering行动对元件进行
    
    另请参见：
    
    forEach(IntConsumer)
  - toArray
```
int[] toArray()
```
    返回包含此流元素的数组。
    这是一个terminal operation。
    
    结果
    
    包含此流元素的数组
  - reduce
```
int reduce(int identity,
           IntBinaryOperator op)
```
    对这一 reduction流元素，使用提供的价值认同和 associative累积函数，返回值减少。这相当于：
```
     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。
    API Note:
    和，最小，最大和平均都是特殊情况下的减少。总结了数字流可以表示为：
    int sum = integers.reduce(0, (a, b) -> a+b);
    或更紧：
    int sum = integers.reduce(0, Integer::sum);
    
    虽然这可能看起来更迂回的方式进行聚集相比简直变异运行总在循环，减少操作并行化更优雅，不需要额外的同步，大大降低了数据竞争的风险。
    参数
    
    identity为累加功能价值认同
    
    op - associative， non-interfering，结合二值 stateless功能
    
    结果
    
    减少的结果
    
    另请参见：
    
    sum()， min()， max()， average()
  - reduce
```
OptionalInt reduce(IntBinaryOperator op)
```
    对这一 reduction流元素，使用 associative累积函数，并返回一个 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。
    参数
    
    op - associative， non-interfering，结合二值 stateless功能
    
    结果
    
    减少的结果
    
    另请参见：
    
    reduce(int, IntBinaryOperator)
  - collect
```
<R> 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。
    参数类型
    
    R -结果类型
    
    参数
    
    supplier -一个功能，创建一个新的结果的容器。对于一个并行执行，这个函数可以被调用多次，每次都必须返回一个新值。
    
    accumulator - associative， non-interfering，将一个额外的元素到一个结果 stateless功能
    
    combiner - associative， non-interfering，结合二值 stateless功能，必须与蓄电池功能兼容
    
    结果
    
    减少的结果
    
    另请参见：
    
    Stream.collect(Supplier, BiConsumer, BiConsumer)
  - sum
```
int sum()
```
    返回此流中元素的和。这是一个 reduction特例，相当于：
```
     return reduce(0, Integer::sum);
 
```
    这是一个terminal operation。
    结果
    
    此流中元素的和
  - min
```
OptionalInt min()
```
    返回一个 OptionalInt描述该流的最小元素，或一个空如果此流是空的。这是一个 reduction特例，相当于：
```
     return reduce(Integer::min);
 
```
    这是一个terminal operation。
    结果
    
    一个 OptionalInt包含此流的最小元素，或一个空的 OptionalInt如果流是空的
  - max
```
OptionalInt max()
```
    返回一个 OptionalInt描述此流的最大元素，或一个空如果此流是空的。这是一个 reduction特例，相当于：
```
     return reduce(Integer::max);
 
```
    这是一个terminal operation。
    结果
    
    一个 OptionalInt包含此流的最大元素，或一个空的 OptionalInt如果流是空的
  - count
```
long count()
```
    返回此流中元素的计数。这是一个 reduction特例，相当于：
```
     return mapToLong(e -> 1L).sum();
 
```
    这是一个terminal operation。
    结果
    
    该流中元素的计数
  - average
```
OptionalDouble average()
```
    返回一个 OptionalDouble描述此流的元素的算术平均值，或一个空如果此流是空的。这是一个 reduction特例。
    这是一个terminal operation。
    
    结果
    
    一个 OptionalDouble包含此流的平均元素，或一个空的可选如果流是空的
  - summaryStatistics
```
IntSummaryStatistics summaryStatistics()
```
    返回一个 IntSummaryStatistics描述该流的元素的各种汇总数据。这是一个 reduction特例。
    这是一个terminal operation。
    
    结果
    
    一个 IntSummaryStatistics描述该流的元素的各种汇总数据
  - anyMatch
```
boolean anyMatch(IntPredicate predicate)
```
    返回此流中的任何元素是否匹配所提供的谓词。如果没有确定结果的所有元素，可能无法评估谓词。如果流是空的话 false返回谓词不评价。
    这是一个short-circuiting terminal operation。
    
    API Note:
    
    此方法评估了存在的量化的谓词的元素的流（为一些X P（X））。
    
    参数
    
    predicate - non-interfering， stateless谓词适用于此流的元素
    
    结果
    
    true如果流的任何元素匹配提供的谓词，否则 false
  - allMatch
```
boolean allMatch(IntPredicate predicate)
```
    返回此流中的所有元素是否匹配所提供的谓词。如果没有确定结果的所有元素，可能无法评估谓词。如果流是空的话 true返回谓词不评价。
    这是一个short-circuiting terminal operation。
    
    API Note:
    
    此方法计算的通用量化的谓词的元素的流（所有的X P（X））。如果流是空的，量化是说是空虚的满足，总是 true（无论P（x））。
    
    参数
    
    predicate - non-interfering， stateless谓词适用于此流的元素
    
    结果
    
    true如果所有元素的流匹配提供的谓词或流为空，否则 false
  - noneMatch
```
boolean noneMatch(IntPredicate predicate)
```
    返回此流中的任何元素是否匹配所提供的谓词。如果没有确定结果的所有元素，可能无法评估谓词。如果流是空的话 true返回谓词不评价。
    这是一个short-circuiting terminal operation。
    
    API Note:
    
    这种方法对否定谓词量词在流元素（所有X ~ P（x））。如果流是空的，量化是说是空虚的满足，总是 true，无论P（x）。
    
    参数
    
    predicate - non-interfering， stateless谓词适用于此流的元素
    
    结果
    
    true如果没有元素的流匹配提供的谓词或流为空，否则 false
  - findFirst
```
OptionalInt findFirst()
```
    返回一个 OptionalInt描述此流的第一个元素，或者一个空的 OptionalInt如果流是空的。如果流没有遇到顺序，则任何元素可能会返回。
    这是一个short-circuiting terminal operation。
    
    结果
    
    一个 OptionalInt描述此流的第一个元素，或者一个空的 OptionalInt如果流是空的
  - findAny
```
OptionalInt findAny()
```
    返回一个 OptionalInt描述一些流元素，或一个空的 OptionalInt如果流是空的。
    这是一个short-circuiting terminal operation。
    
    该操作行为明确不确定的；它是自由的选择流中的任何元素。这是为了允许在并行操作的最大性能；成本是在同一来源的多个调用不返回相同的结果。（如果一个稳定的结果是预期的，使用findFirst()代替。）
    
    结果
    
    一个 OptionalInt描述此流的元素，或一个空的 OptionalInt如果流是空的
    
    另请参见：
    
    findFirst()
  - asLongStream
```
LongStream asLongStream()
```
    返回一个包含该流的元素 LongStream，转换为 long。
    这是一个intermediate operation。
    
    结果
    
    由该流的元素 LongStream，转换为 long
  - asDoubleStream
```
DoubleStream asDoubleStream()
```
    返回一个包含该流的元素 DoubleStream，转换为 double。
    这是一个intermediate operation。
    
    结果
    
    由该流的元素 DoubleStream，转换为 double
  - boxed
```
Stream<Integer> boxed()
```
    返回一个包含该流的元素 Stream，每盒装一 Integer。
    这是一个intermediate operation。
    
    结果
    
    一个 Stream对该流的元素一致，每盒装一 Integer
  - sequential
```
IntStream sequential()
```
    从接口复制的描述： BaseStream
    
    返回一个连续的等效流。可以返回本身，或者是因为流已经是连续的，或是因为底层的流状态被修改为连续的。
    这是一个intermediate operation。
    
    Specified by:
    
    sequential 接口 BaseStream<Integer,IntStream>
    
    结果
    
    顺序流
  - parallel
```
IntStream parallel()
```
    从接口复制的描述： BaseStream
    
    返回一个并行的等效流。可以返回本身，无论是因为流已经是并行的，或是因为底层的流状态被修改为并行。
    这是一个intermediate operation。
    
    Specified by:
    
    parallel 接口 BaseStream<Integer,IntStream>
    
    结果
    
    平行流
  - iterator
```
PrimitiveIterator.OfInt iterator()
```
    从接口复制的描述： BaseStream
    
    返回此流的元素的迭代器。
    这是一个terminal operation。
    
    Specified by:
    
    iterator 接口 BaseStream<Integer,IntStream>
    
    结果
    
    此流的元素迭代器
  - spliterator
```
Spliterator.OfInt spliterator()
```
    从接口复制的描述： BaseStream
    
    返回一个对该流的元素spliterator。
    这是一个terminal operation。
    
    Specified by:
    
    spliterator 接口 BaseStream<Integer,IntStream>
    
    结果
    
    该流的元素spliterator
  - 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)
```
    返回一个无穷序列有序 IntStream由最初的一元 seed函数的 f迭代应用产生的，产生一个由 seed， f(seed)， f(f(seed)) Stream，等
    第一单元（位置0）在IntStream将提供seed。对于n > 0，位置n元素，将在位置n - 1元素的应用功能f结果。
    
    参数
    
    seed -初始元
    
    f -函数被应用到以前的元素产生一个新的元素
    
    结果
    
    一种新的序列 IntStream
  - generate
```
static IntStream generate(IntSupplier s)
```
    返回一个无穷序列无序流，其中每个元素是由提供 IntSupplier产生。这是适合产生恒流，随机元素流，等。
    
    参数
    
    s -生成元素的 IntSupplier
    
    结果
    
    一个新的无限序列的无序 IntStream
  - range
```
static IntStream range(int startInclusive,
                       int endExclusive)
```
    返回一个有序 IntStream从 startInclusive（含）至 endExclusive（独家）由 1增量步。
    API Note:
    增加值相等的序列可以按顺序使用for回路如下生产：
    
    for (int i = startInclusive; i < endExclusive ; i++) { ... }
    参数
    
    startInclusive -（含）的初始值
    
    endExclusive -独家上限
    
    结果
    
    为 int元素顺序 IntStream范围
  - rangeClosed
```
static IntStream rangeClosed(int startInclusive,
                             int endInclusive)
```
    返回一个有序 IntStream从 startInclusive（含）至 endInclusive（含）的 1增量步。
    API Note:
    增加值相等的序列可以按顺序使用for回路如下生产：
    
    for (int i = startInclusive; i <= endInclusive ; i++) { ... }
    参数
    
    startInclusive -（含）的初始值
    
    endInclusive的包容上限
    
    结果
    
    为 int元素顺序 IntStream范围
  - concat
```
static IntStream concat(IntStream a,
                        IntStream b)
```
    创建一个懒洋洋的级联流的元素的所有元素的第一流通过第二个流的元素。将得到的流排序，如果这两个输入流的命令，和并行，如果任一的输入流是平行的。当所产生的流被关闭时，两个输入流的关闭处理程序被调用。
    
    Implementation Note:
    
    当构建流从重复串联谨慎使用。访问一个深深的级联流元件具有较深的调用链，甚至 StackOverflowException。
    
    参数
    
    a -第一流
    
    b -二流
    
    结果
    
    这两个输入流连接

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Interface IntStream

Nested Class Summary

方法摘要

Methods inherited from interface java.util.stream.BaseStream

方法详细信息

filter

map

mapToObj

mapToLong

mapToDouble

flatMap

distinct

sorted

peek

limit

skip

forEach

forEachOrdered

toArray

reduce

reduce

collect

sum

min

max

count

average

summaryStatistics

anyMatch

allMatch

noneMatch

findFirst

findAny

asLongStream

asDoubleStream

boxed

sequential

parallel

iterator

spliterator

builder

empty

of

of

iterate

generate

range

rangeClosed

concat