IntStream (Java Platform SE 8 )

All Superinterfaces:

AutoCloseable ， BaseStream < Integer ， IntStream >
```
public interface IntStream
extends BaseStream<Integer,IntStream>
```
支持顺序和并行聚合操作的原始int值元素序列。这是int原始专业Stream 。
以下示例说明使用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

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`此流的元素的算术平均值的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`由函数的迭代应用产生 `f`至初始元素 `seed` ，产生 `Stream`包括 `seed` ， `f(seed)` ， `f(f(seed))` ，等
`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，如果此流为空，则返回一个空的可选项。
`OptionalInt`	`min()` 返回 `OptionalInt`此流的最小元素的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)` 从 `startInclusive` （含）的顺序排列 `IntStream`到 `endInclusive` （含），增量步长为 `1` 。
`OptionalInt`	`reduce(IntBinaryOperator op)` 使用 associative累积函数对此流的元素执行 reduction ，并返回描述减小值的 `OptionalInt` （如果有）。
`int`	`reduce(int identity, IntBinaryOperator op)` 使用提供的身份值和 associative累积功能对此流的元素执行 reduction ，并返回减小的值。
`IntStream`	`sequential()` 返回顺序的等效流。
`IntStream`	`skip(long n)` 在丢弃流的第一个 `n`元素后，返回由该流的 `n`元素组成的流。
`IntStream`	`sorted()` 以排序顺序返回由该流的元素组成的流。
`Spliterator.OfInt`	`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 - a 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元素组成的流。如果此流包含少于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)
```
    使用提供的身份值和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 。
    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)
```
    使用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 。
    参数
    
    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此流的最小元素的OptionalInt，如果此流为空，则返回一个空的可选项。这是一个reduction的特殊情况，相当于：
```
   return reduce(Integer::min);  
```
    这是一个terminal operation 。
    结果
    
    一个 OptionalInt此流的最小元素的 OptionalInt如果流为空， OptionalInt
  - max
```
OptionalInt max()
```
    返回OptionalInt此流的最大元素的OptionalInt，如果此流为空，则返回一个空的可选项。这是一个reduction的特殊情况，相当于：
```
   return reduce(Integer::max);  
```
    这是一个terminal operation 。
    结果
    
    一个 OptionalInt此流的最大元素的 OptionalInt如果流为空， OptionalInt
  - count
```
long count()
```
    返回此流中的元素数。这是一个reduction的特殊情况，相当于：
```
   return mapToLong(e -> 1L).sum();  
```
    这是一个terminal operation 。
    结果
    
    这个流中元素的数量
  - average
```
OptionalDouble average()
```
    返回OptionalDouble此流的元素的算术平均值的OptionalDouble，如果此流为空，则返回一个空的可选项。这是一个reduction的特例。
    这是一个terminal operation 。
    
    结果
    
    一个 OptionalDouble此流的平均元素的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如果流为空， OptionalInt
  - findAny
```
OptionalInt findAny()
```
    返回描述流的某些元素的OptionalInt如果流为空，则返回一个空的OptionalInt 。
    这是一个short-circuiting terminal operation 。
    
    这个操作的行为显然是不确定的; 可以自由选择流中的任何元素。这是为了允许并行操作中的最大性能; 成本是同一来源上的多次调用可能不会返回相同的结果。（如果需要稳定的结果，请改用findFirst() ）
    
    结果
    
    一个 OptionalInt此流的某些元素的 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复制
    
    返回此流的元素的拼接器。
    这是一个terminal operation 。
    
    Specified by:
    
    spliterator在界面 BaseStream<Integer,IntStream>
    
    结果
    
    该流的元素拼接器
  - 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由函数的迭代应用产生f至初始元素seed ，产生Stream包括seed ， f(seed) ， f(f(seed)) ，等
    第一元件（位置0在） IntStream将是提供seed 。对于n > 0 ，位置n处的元素将是将函数f应用于位置n - 1的元素的n - 1 。
    
    参数
    
    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 - 独占上限
    
    结果
    
    一个顺序 IntStream的范围为 int元素
  - rangeClosed
```
static IntStream rangeClosed(int startInclusive,
                             int endInclusive)
```
    返回有序顺序 IntStream从 startInclusive （含）至 endInclusive通过的递增步长（含） 1 。
    API Note:
    可以使用for循环顺序地产生递增值的等效序列，如下所示：
    
    for (int i = startInclusive; i <= endInclusive ; i++) { ... }
    参数
    
    startInclusive - （含）初始值
    
    endInclusive - 包含上限
    
    结果
    
    顺序 IntStream为的范围 int元件
  - concat
```
static IntStream concat(IntStream a,
                        IntStream b)
```
    创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。如果两个输入流都被排序，则生成的流被排序，并且如果任何一个输入流是并行的，则并行。当结果流关闭时，调用两个输入流的关闭处理程序。
    
    Implementation Note:
    
    在重复连接构建流时要小心。访问深层级流的元素可能导致深度的调用链，甚至可以导致StackOverflowException 。
    
    参数
    
    a - 第一个流
    
    b - 第二个流
    
    结果
    
    两个输入流的并置

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