Interface IntStream

最新推荐文章于 2024-07-27 10:19:50 发布

qq_27000425

最新推荐文章于 2024-07-27 10:19:50 发布

阅读量3.4k

点赞数 1

分类专栏： Interface 文章标签： intStream

Interface 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一个序列的原始int-valued元素支持顺序和并行聚合操作。

compact1，compact2，compact3

java.util.stream

接口IntStream

所有超级接口：
AutoCloseable， BaseStream < Integer， IntStream >
公共接口IntStream 扩展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

- 嵌套类摘要
- 嵌套类
  
  修饰符和类型
  
  界面和说明
  
  static interface
  
  IntStream.Builder
  
  一个可变的构建器 IntStream。
- 方法摘要
- 所有方法静态方法实例方法抽象方法默认方法
  
  修饰符和类型
  
  方法和说明
  
  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()
  
  返回由该流的不同元素组成的流。
  
  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
  
  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)
  
  执行减少有关此流的元件，使用缔合累积功能，并返回一个 OptionalInt描述该减小值，如果有的话。
  
  int
  
  reduce(int identity, IntBinaryOperator op)
  
  执行还原上使用所提供的标识值和所述本流的元素，缔累积功能，并返回减少值。
  
  IntStream
  
  sequential()
  
  返回顺序的等效流。
  
  IntStream
  
  skip(long n)
  
  在丢弃流的第一个 n元素后，返回由该流的剩余元素组成的流。
  
  IntStream
  
  sorted()
  
  以排序顺序返回由该流的元素组成的流。
  
  Spliterator.OfInt
  
  spliterator()
  
  返回此流的元素的拼接器。
  
  int
  
  sum()
  
  返回此流中元素的总和。
  
  IntSummaryStatistics
  
  summaryStatistics()
  
  返回 IntSummaryStatistics描述有关此流的元素的各种摘要数据。
  
  int[]
  
  toArray()
  
  返回一个包含此流的元素的数组。
  - close, isParallel, onClose, unordered
  - 从java.util.stream接口继承的方法。BaseStream

- 方法详细
  - 过滤
  - IntStream 过滤器（IntPredicate 谓词）
  - 返回由与此给定谓词匹配的此流的元素组成的流。
    这是一个中间操作。
  - 参数：
    predicate-一个非干扰，无国籍谓词应用到每个元素，以确定是否它应包含
    返回：
    新的流
- - 地图
  - IntStream 映射（IntUnaryOperator 映射器）
  - 返回由给定函数应用于此流的元素的结果组成的流。
    这是一个中间操作。
  - 参数：
    mapper- 一个无干扰的，无状态的功能，适用于每个元素
    返回：
    新的流
- - mapToObj
  - <U> Stream <U> mapToObj（IntFunction <？extends U> mapper）
  - 返回一个对象值Stream，其中包含将给定函数应用于此流的元素的结果。
    这是一个中间操作。
  - 类型参数：
    U - 新流的元素类型
    参数：
    mapper- 一个无干扰的，无状态的功能，适用于每个元素
    返回：
    新的流
- - mapToLong
  - LongStream mapToLong（IntToLongFunction 映射器）
  - 返回一个LongStream由给定函数应用于此流的元素的结果。
    这是一个中间操作。
  - 参数：
    mapper- 一个无干扰的，无状态的功能，适用于每个元素
    返回：
    新的流
- - mapToDouble
  - DoubleStream mapToDouble（IntToDoubleFunction mapper）
  - 返回一个DoubleStream由给定函数应用于此流的元素的结果。
    这是一个中间操作。
  - 参数：
    mapper- 一个无干扰的，无状态的功能，适用于每个元素
    返回：
    新的流
- - flatMap
  - IntStream flatMap（IntFunction <？extends IntStream > mapper）
  - 返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。每个映射的流 closed在其内容已经被放入此流之后。（如果使用映射的流是null 空的流）。
    这是一个中间操作。
  - 参数：
    mapper-一个非干扰，无状态功能应用到其中产生的每个元素 IntStream的新值的
    返回：
    新的流
    也可以看看：
    Stream.flatMap(Function)
- - 不同
  - IntStream distinct（）
  - 返回由该流的不同元素组成的流。
    这是一个有状态的中间操作。
  - 返回：
    新的流
- - 分类
  - IntStream sorted（）
  - 以排序顺序返回由该流的元素组成的流。
    这是一个有状态的中间操作。
  - 返回：
    新的流
- - 窥视
  - IntStream 偷看（IntConsumer 动作）
  - 返回由该流的元素组成的流，另外在从生成的流中消耗元素时对每个元素执行提供的操作。
    这是一个中间操作。
    
    对于并行流管线，可以在上游操作的任何时间和任何线程中调用该元素可用的动作。如果操作修改共享状态，则负责提供所需的同步。
  - 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();
    参数：
    action- 在流中消耗的元素上执行的非干扰操作
    返回：
    新的流
- - 限制
  - IntStream limit（long maxSize）
  - 返回由该流的元素组成的流，被截断为不再maxSize长度。
    这是一个短暂的有状态的中间操作。
  - API注：
    虽然 limit()在顺序流管线上通常是一种便宜的操作，但是在有序的并行管道上可能是相当昂贵的，特别是对于大的值 maxSize，因为 limit(n) 限制不仅返回任何 n个元素，而且返回遇到顺序中的 前n个元素。如果您的情况允许，使用无序流源（如 generate(IntSupplier)）或删除排序约束 BaseStream.unordered()可能会导致 limit()并行流水线的显着加速。如果需要与遇到顺序一致，并且 limit()在并行管道中遇到较差的性能或内存利用率，则切换到顺序执行 sequential()可能会提高性能。
    参数：
    maxSize - 流应该限制的元素数量
    返回：
    新的流
    抛出：
    IllegalArgumentException- 如果 maxSize是否定的
- - 跳跃
  - IntStream skip（long n）
  - 在丢弃流的第一个n元素后，返回由该流的剩余元素组成的流。如果此流包含少于n元素，则将返回空流。
    这是一个有状态的中间操作。
  - API注：
    虽然 skip()通常是顺序流管线上的廉价操作，但在有序的并行管道上可能是相当昂贵的，特别是对于大值 n，因为 skip(n) 被限制为不仅跳过任何 n个元素，而且跳过遇到次序中的 前n个元素。如果您的情况允许，使用无序流源（如 generate(IntSupplier)）或删除排序约束 BaseStream.unordered()可能会导致 skip()并行流水线的显着加速。如果需要与遇到顺序一致，并且 skip()在并行管道中遇到较差的性能或内存利用率，则切换到顺序执行 sequential()可能会提高性能。
    参数：
    n - 要跳过的主要元素的数量
    返回：
    新的流
    抛出：
    IllegalArgumentException- 如果 n是否定的
- - 的forEach
  - void forEach（IntConsumer 动作）
  - 对此流的每个元素执行操作。
    这是一个终端操作。
    
    对于并行流管道，此操作不能保证遵守流的遇到顺序，因为这样做会牺牲并行性的好处。对于任何给定的元素，动作可以在图书馆选择的任何时间和任何线索中执行。如果操作访问共享状态，则负责提供所需的同步。
  - 参数：
    action- 对元素执行不干扰的行为
- - forEachOrdered
  - void forEachOrdered（IntConsumer 动作）
  - 对此流的每个元素执行一个操作，保证每个元素按遇到顺序处理，以便具有定义的遇到顺序的流。
    这是一个终端操作。
  - 参数：
    action- 对元素执行不干扰的行为
    也可以看看：
    forEach(IntConsumer)
- - 指定者
  - int [] toArray（）
  - 返回一个包含此流的元素的数组。
    这是一个终端操作。
  - 返回：
    一个包含此流的元素的数组
- - 减少
  - 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注：
    总和，最小，最大和平均都是减少的特殊情况。一个数字流可以表示为：
    int sum = integers.reduce(0, (a, b) -> a+b);
    或更紧凑：
    int sum = integers.reduce(0, Integer::sum);
    
    尽管与简单地将循环中的总体变量相比，这可能看起来更为迂回的方式进行，但减少操作更平稳地并行化，而不需要额外的同步，并大大降低了数据竞争的风险。
    参数：
    identity - 积累函数的身份值
    
    op-一个关联，无干扰，无状态的组合两个值函数
    返回：
    减少的结果
    也可以看看：
    sum()， min()， max()， average()
- - 减少
  - 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)
- - 搜集
  - 收集（供应商，供应商，对象消费者，聚合器， BiConsumer <R，R>组合器）
  - 对此流的元素执行可变缩减操作。可变缩减是其中减值是可变结果容器的缩减值，例如，ArrayList通过更新结果的状态而不是通过替换结果来合并元素。这产生的结果相当于：
```
     R result = supplier.get();
     for (int element : this stream)
         accumulator.accept(result, element);
     return result;
 
```
    像这样reduce(int, IntBinaryOperator)，collect操作可以并行化，而不需要额外的同步。
    
    这是一个终端操作。
  - 类型参数：
    R - 结果的类型
    参数：
    supplier - 创建新结果容器的函数。对于并行执行，可以多次调用此函数，并且每次都必须返回一个新的值。
    
    accumulator-一个缔合，非干扰性，无状态用于将一个额外的元件到结果函数
    
    combiner-一个缔合，非干扰，无状态功能用于组合两个值，它必须与蓄能器功能兼容
    返回：
    减少的结果
    也可以看看：
    Stream.collect(Supplier, BiConsumer, BiConsumer)
- - 和
  - int sum（）
  - 返回此流中元素的总和。这是减少的特殊情况，相当于：
```
     return reduce(0, Integer::sum);
 
```
    这是一个终端操作。
  - 返回：
    这个流中元素的总和
- - 分
  - OptionalInt min（）
  - 返回OptionalInt描述此流的最小元素，如果此流为空，则返回空可选项。这是减少的特殊情况，相当于：
```
     return reduce(Integer::min);
 
```
    这是一个终端操作。
  - 返回：
    一个 OptionalInt包含此流的最小元素， OptionalInt如果流为空，则为空
- - 最大
  - OptionalInt max（）
  - 返回OptionalInt描述此流的最大元素，如果此流为空，则返回空可选项。这是减少的特殊情况，相当于：
```
     return reduce(Integer::max);
 
```
    这是一个终端操作。
  - 返回：
    包含 OptionalInt此流的最大元素， OptionalInt如果流为空，则为空
- - 计数
  - 长计数（）
  - 返回此流中的元素数。这是减少的特殊情况，相当于：
```
     return mapToLong(e -> 1L).sum();
 
```
    这是一个终端操作。
  - 返回：
    这个流中元素的数量
- - 平均
  - OptionalDouble average（）
  - 返回OptionalDouble描述此流的元素的算术平均值，如果此流为空，则返回空值。这是减少的一个特例。
    这是一个终端操作。
  - 返回：
    一个 OptionalDouble包含此流的平均元素，如果流为空，则为空可选
- - summaryStatistics
  - IntSummaryStatistics summaryStatistics（）
  - 返回IntSummaryStatistics描述有关此流的元素的各种摘要数据。这是减少的一个特例。
    这是一个终端操作。
  - 返回：
    一个 IntSummaryStatistics有关此流中的元素描述各种摘要数据
- - anyMatch
  - boolean anyMatch（IntPredicate 谓词）
  - 返回此流的任何元素是否与提供的谓词匹配。如果不需要确定结果，则不能评估所有元素上的谓词。如果流为空， false则返回并且不评估谓词。
    这是一个短路终端操作。
  - API注：
    该方法评估了流的元素（对于某些x P（x））的谓词的存在量化。
    参数：
    predicate-一个无干扰，无状态的断言适用于该流的元素
    返回：
    true 如果流的任何元素与提供的谓词匹配，否则 false
- - allMatch
  - boolean allMatch（IntPredicate 谓词）
  - 返回此流的所有元素是否与提供的谓词匹配。如果不需要确定结果，则不能评估所有元素上的谓词。如果流为空，true则返回并且不评估谓词。
    这是一个短路终端操作。
  - API注：
    该方法评估了流的元素（对于所有x P（x））的谓词的 通用量化。如果流是空的，量化据说是 空洞地满足，总是 true（不管的P（X））。
    参数：
    predicate-一个无干扰，无状态的断言适用于该流的元素
    返回：
    true 如果流的所有元素与提供的谓词匹配，否则流为空，否则 false
- - noneMatch
  - boolean noneMatch（IntPredicate 谓词）
  - 返回此流的元素是否与提供的谓词匹配。如果不需要确定结果，则不能评估所有元素上的谓词。如果流为空，true则返回并且不评估谓词。
    这是一个短路终端操作。
  - API注：
    此方法评估 普遍量化通过该流中的元素的否定谓词的（对于所有的x〜P（X））。如果流是空的，那么量化被认为是空虚的，并且总是 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。
    这是一个中间操作。
  - 返回：
    a LongStream由这个流的元素组成，转换为 long
- - asDoubleStream
  - DoubleStream asDoubleStream（）
  - 返回由DoubleStream该流的元素组成的转换为double。
    这是一个中间操作。
  - 返回：
    a DoubleStream由这个流的元素组成，转换为 double
- - 盒装
  - Stream < Integer > boxed（）
  - 返回一个Stream由此流的元素组成的，每个元素包含一个Integer。
    这是一个中间操作。
  - 返回：
    一个 Stream一致的此流的元件，每个盒装到 Integer
- - 顺序
  - IntStream 序列（）
  - 说明从界面复制： BaseStream
  - 返回顺序的等效流。可能返回自己，因为流已经是顺序的，或者因为底层流状态被修改为顺序的。
    这是一个中间操作。
  - 指定者：
    sequential 在界面 BaseStream<Integer,IntStream>
    返回：
    顺序流
- - 平行
  - IntStream parallel（）
  - 说明从界面复制： BaseStream
  - 返回平行的等效流。可能会返回自己，因为流已经是并行的，或者因为底层流状态被修改为并行。
    这是一个中间操作。
  - 指定者：
    parallel 在界面 BaseStream<Integer,IntStream>
    返回：
    并行流
- - 迭代器
  - PrimitiveIterator.OfInt iterator（）
  - 说明从界面复制： BaseStream
  - 返回此流的元素的迭代器。
    这是一个终端操作。
  - 指定者：
    iterator 在界面 BaseStream<Integer,IntStream>
    返回：
    该流的元素迭代器
- - spliterator
  - Spliterator.OfInt 拼接器（）
  - 说明从界面复制： BaseStream
  - 返回此流的元素的拼接器。
    这是一个终端操作。
  - 指定者：
    spliterator 在界面 BaseStream<Integer,IntStream>
    返回：
    该流的元素拼接器
- - 建设者
  - 静态 IntStream.Builder builder（）
  - 返回一个生成器IntStream。
  - 返回：
    流构建器
- - 空
  - 静态 IntStream 空（）
  - 返回一个空的顺序IntStream。
  - 返回：
    一个空的顺序流
- - 的
  - （int t）的静态 IntStream
  - 返回包含IntStream单个元素的顺序。
  - 参数：
    t - 单一元素
    返回：
    单例顺序流
- - 的
  - 静态 intStream （int ... values）
  - 返回其元素是指定值的顺序排序流。
  - 参数：
    values - 新流的元素
    返回：
    新的流
- - 迭代
  - 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。
  - 参数：
    seed - 初始元素
    
    f - 要应用于上一个元素以生成新元素的函数
    返回：
    一个新的顺序 IntStream
- - 生成
  - 静态 IntStream 生成（IntSupplier s）
  - 返回无限顺序无序流，其中每个元素由提供的每个元素生成IntSupplier。这适合于产生恒定流，随机元素流等
  - 参数：
    s- IntSupplier用于生成的元素
    返回：
    一个新的无限顺序无序 IntStream
- - 范围
  - 静态 IntStream 范围（int startInclusive， int endExclusive）
  - 通过增量步骤返回IntStream从startInclusive （包括）到endExclusive（排除）的顺序排列 1。
  - API注：
    可以使用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注：
    可以使用for循环如下顺序地产生递增值的等效序列：
    
    for (int i = startInclusive; i <= endInclusive ; i++) { ... }
    参数：
    startInclusive - （含）初始值
    
    endInclusive - 包容上限
    返回：
    顺序 IntStream为的范围内 int 的元件
- - CONCAT
  - 静态 IntStream concat（IntStream a， IntStream b）
  - 创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。如果两个输入流都被排序，则生成的流被排序，并且如果任何一个输入流是并行的，则并行。当结果流关闭时，调用两个输入流的关闭处理程序。
  - 实施注：
    
    在重复连接构建流时要小心。访问深层级流的元素可能导致深度的调用链，甚至可能 StackOverflowException。
    
    参数：
    
    a - 第一流
    
    b - 第二流
    
    返回：
    
    两个输入流的并置