LongStream (Java Platform SE 8 )

All Superinterfaces:

AutoCloseable ， BaseStream < Long ， LongStream >
```
public interface LongStream
extends BaseStream<Long,LongStream>
```
支持顺序和并行聚合操作的原始长值元素序列。这是long原始专业Stream 。
以下示例说明使用Stream和LongStream的汇总操作，计算红色小部件的权重之和：
```
   long sum = widgets.stream() .filter(w -> w.getColor() == RED) .mapToLong(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`	`LongStream.Builder` `LongStream`可变构建器。

方法摘要

所有方法静态方法接口方法抽象方法 Default Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(LongPredicate predicate)` 返回此流的所有元素是否与提供的谓词匹配。
`boolean`	`anyMatch(LongPredicate predicate)` 返回此流的任何元素是否与提供的谓词匹配。
`DoubleStream`	`asDoubleStream()` 返回一个 `DoubleStream`由该流中的元素，转换为 `double` 。
`OptionalDouble`	`average()` 返回 `OptionalDouble`此流的元素的算术平均值的OptionalDouble，如果此流为空，则返回一个空的可选项。
`Stream<Long>`	`boxed()` 返回一个 `Stream`由该流的盒装到所述的元件，每个的 `Long` 。
`static LongStream.Builder`	`builder()` 返回一个 `LongStream`的生成器。
`<R> R`	`collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R,R> combiner)` 对此流的元素执行 mutable reduction操作。
`static LongStream`	`concat(LongStream a, LongStream b)` 创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
`long`	`count()` 返回此流中的元素数。
`LongStream`	`distinct()` 返回由该流的不同元素组成的流。
`static LongStream`	`empty()` 返回一个空的顺序 `LongStream` 。
`LongStream`	`filter(LongPredicate predicate)` 返回由与此给定谓词匹配的此流的元素组成的流。
`OptionalLong`	`findAny()` 返回描述流的一些元素的`OptionalLong`如果流为空，则返回一个空的`OptionalLong` 。
`OptionalLong`	`findFirst()` 返回描述此流的第一个元素的`OptionalLong`如果流为空，则返回空的`OptionalLong` 。
`LongStream`	`flatMap(LongFunction<? extends LongStream> mapper)` 返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。
`void`	`forEach(LongConsumer action)` 对此流的每个元素执行操作。
`void`	`forEachOrdered(LongConsumer action)` 对此流的每个元素执行一个操作，保证每个元素按遇到顺序处理，以便具有定义的遇到顺序的流。
`static LongStream`	`generate(LongSupplier s)` 返回无限顺序无序流，其中每个元素由提供的 `LongSupplier` 。
`static LongStream`	`iterate(long seed, LongUnaryOperator f)` 返回有序无限连续 `LongStream`由函数的迭代应用产生 `f`至初始元素 `seed` ，产生 `Stream`包括 `seed` ， `f(seed)` ， `f(f(seed))` ，等
`PrimitiveIterator.OfLong`	`iterator()` 返回此流的元素的迭代器。
`LongStream`	`limit(long maxSize)` 返回由此流的元素组成的流，截断长度不能超过 `maxSize` 。
`LongStream`	`map(LongUnaryOperator mapper)` 返回由给定函数应用于此流的元素的结果组成的流。
`DoubleStream`	`mapToDouble(LongToDoubleFunction mapper)` 返回一个 `DoubleStream` ，其中包含将给定函数应用于此流的元素的结果。
`IntStream`	`mapToInt(LongToIntFunction mapper)` 返回一个 `IntStream` ，其中包含将给定函数应用于此流的元素的结果。
`<U> Stream<U>`	`mapToObj(LongFunction<? extends U> mapper)` 返回一个对象值 `Stream` ，其中包含将给定函数应用于此流的元素的结果。
`OptionalLong`	`max()` 返回 `OptionalLong`此流的最大元素的OptionalLong，如果此流为空，则返回一个空的可选项。
`OptionalLong`	`min()` 返回 `OptionalLong`此流的最小元素的OptionalLong，如果此流为空，则返回一个空的可选项。
`boolean`	`noneMatch(LongPredicate predicate)` 返回此流的元素是否与提供的谓词匹配。
`static LongStream`	`of(long... values)` 返回其元素是指定值的顺序排序流。
`static LongStream`	`of(long t)` 返回包含单个元素的顺序 `LongStream` 。
`LongStream`	`parallel()` 返回平行的等效流。
`LongStream`	`peek(LongConsumer action)` 返回由该流的元素组成的流，另外在从生成的流中消耗元素时对每个元素执行提供的操作。
`static LongStream`	`range(long startInclusive, long endExclusive)` 返回有序的顺序 `LongStream`从 `startInclusive` （含）至 `endExclusive`通过增量步骤（独家） `1` 。
`static LongStream`	`rangeClosed(long startInclusive, long endInclusive)` 返回有序顺序 `LongStream`从 `startInclusive` （含）至 `endInclusive`通过的递增步长（含） `1` 。
`OptionalLong`	`reduce(LongBinaryOperator op)` 使用 associative累积功能对此流的元素执行 reduction ，并返回描述减小值的 `OptionalLong` （如果有）。
`long`	`reduce(long identity, LongBinaryOperator op)` 使用提供的身份值和 associative累积功能对此流的元素执行 reduction ，并返回减小的值。
`LongStream`	`sequential()` 返回顺序的等效流。
`LongStream`	`skip(long n)` 在丢弃流的第一个 `n`元素后，返回由该流的 `n`元素组成的流。
`LongStream`	`sorted()` 以排序顺序返回由该流的元素组成的流。
`Spliterator.OfLong`	`spliterator()` 返回此流的元素的拼接器。
`long`	`sum()` 返回此流中元素的总和。
`LongSummaryStatistics`	`summaryStatistics()` 返回一个 `LongSummaryStatistics`描述有关此流的元素的各种摘要数据。
`long[]`	`toArray()` 返回一个包含此流的元素的数组。

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

- 方法详细信息
  - filter
```
LongStream filter(LongPredicate predicate)
```
    返回由与此给定谓词匹配的此流的元素组成的流。
    这是一个intermediate operation 。
    
    参数
    
    predicate - a non-interfering，stateless 谓词适用于每个元素，以确定是否应包括
    
    结果
    
    新的流
  - map
```
LongStream map(LongUnaryOperator mapper)
```
    返回由给定函数应用于此流的元素的结果组成的流。
    这是一个intermediate operation 。
    
    参数
    
    mapper -一个 non-interfering ， stateless函数应用到每个元件
    
    结果
    
    新的流
  - mapToObj
```
<U> Stream<U> mapToObj(LongFunction<? extends U> mapper)
```
    返回一个对象值Stream ，其中包含将给定函数应用于此流的元素的结果。
    这是一个intermediate operation 。
    
    参数类型
    
    U - 新流的元素类型
    
    参数
    
    mapper -一个 non-interfering ， stateless函数应用到每个元件
    
    结果
    
    新的流
  - mapToInt
```
IntStream mapToInt(LongToIntFunction mapper)
```
    返回一个IntStream ，其中包含将给定函数应用于此流的元素的结果。
    这是一个intermediate operation 。
    
    参数
    
    mapper -一个 non-interfering ， stateless函数应用到每个元件
    
    结果
    
    新的流
  - mapToDouble
```
DoubleStream mapToDouble(LongToDoubleFunction mapper)
```
    返回一个DoubleStream ，其中包含将给定函数应用于此流的元素的结果。
    这是一个intermediate operation 。
    
    参数
    
    mapper -一个 non-interfering ， stateless函数应用到每个元件
    
    结果
    
    新的流
  - flatMap
```
LongStream flatMap(LongFunction<? extends LongStream> mapper)
```
    返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。每个映射的流在其内容被放入此流之后是closed 。（如果映射的流为null则使用空的流。）
    这是一个intermediate operation 。
    
    参数
    
    mapper -一个 non-interfering ， stateless功能应用到其产生的每个元素 LongStream新值的
    
    结果
    
    新的流
    
    另请参见：
    
    Stream.flatMap(Function)
  - distinct
```
LongStream distinct()
```
    返回由该流的不同元素组成的流。
    这是一个stateful intermediate operation 。
    
    结果
    
    新的流
  - sorted
```
LongStream sorted()
```
    以排序顺序返回由该流的元素组成的流。
    这是一个stateful intermediate operation 。
    
    结果
    
    新的流
  - peek
```
LongStream peek(LongConsumer action)
```
    返回由该流的元素组成的流，另外在从生成的流中消耗元素时对每个元素执行提供的操作。
    这是一个intermediate operation 。
    
    对于并行流管线，可以在上游操作的任何时间和任何线程中调用该元素可用的动作。如果操作修改共享状态，则负责提供所需的同步。
    API Note:
    该方法主要用于支持调试，您希望在流程中流过某个特定点时查看元素：
    LongStream.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
```
LongStream limit(long maxSize)
```
    返回由此流的元素组成的流，截短长度不能超过maxSize 。
    这是一个short-circuiting stateful intermediate operation 。
    
    API Note:
    
    虽然limit()通常是在连续的流管道的廉价的操作，它可以是订购的并行管线相当昂贵的，特别是对于大的值maxSize ，由于limit(n)被约束返回不是任何n个元素，但在遭遇顺序中的第n个元素。使用无序流源（如generate(LongSupplier) ）或去除所述排序约束与BaseStream.unordered()可导致显著加速比limit()在并行管线，如果情况许可的语义。如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与limit()在并行管线，在切换到的顺序执行与sequential()可以提高性能。
    
    参数
    
    maxSize - 流应该限制的元素数量
    
    结果
    
    新的流
    
    异常
    
    IllegalArgumentException - 如果 maxSize为负数
  - skip
```
LongStream skip(long n)
```
    在丢弃流的第一个n元素后，返回由该流的n元素组成的流。如果此流包含少于n元素，则将返回空流。
    这是一个stateful intermediate operation 。
    
    API Note:
    
    虽然skip()通常是在连续的流管道的廉价的操作，它可以是订购的并行管线相当昂贵的，特别是对于大的值n ，由于skip(n)被约束为跳过不是任何n个元素，但在遭遇顺序中的第n个元素。使用无序流源（如generate(LongSupplier) ）或去除所述排序约束与BaseStream.unordered()可导致显著加速比skip()在并行管线，如果情况许可的语义。如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与skip()在并行管线，在切换到的顺序执行与sequential()可以提高性能。
    
    参数
    
    n - 要跳过的主要元素的数量
    
    结果
    
    新的流
    
    异常
    
    IllegalArgumentException - 如果 n为负数
  - forEach
```
void forEach(LongConsumer action)
```
    对此流的每个元素执行操作。
    这是一个terminal operation 。
    
    对于并行流管道，此操作不保证遵守流的遇到顺序，因为这样做将牺牲并行性的好处。对于任何给定的元素，动作可以在图书馆选择的任何时间和任何线索中执行。如果操作访问共享状态，则负责提供所需的同步。
    
    参数
    
    action - 一个 non-interfering对元素执行的动作
  - forEachOrdered
```
void forEachOrdered(LongConsumer action)
```
    对此流的每个元素执行一个操作，保证每个元素按遇到顺序处理，以便具有定义的遇到顺序的流。
    这是一个terminal operation 。
    
    参数
    
    action - 一个 non-interfering对元素执行的动作
    
    另请参见：
    
    forEach(LongConsumer)
  - toArray
```
long[] toArray()
```
    返回一个包含此流的元素的数组。
    这是一个terminal operation 。
    
    结果
    
    一个包含此流的元素的数组
  - reduce
```
long reduce(long identity,
            LongBinaryOperator op)
```
    使用提供的身份值和associative累积功能对此流的元素执行reduction ，并返回减小的值。这相当于：
```
   long result = identity; for (long element : this stream) result = accumulator.applyAsLong(result, element) return result;  
```
    但不限于顺序执行。
    identity值必须是累加器功能的标识。这意味着，对于所有x ， accumulator.apply(identity, x)等于x 。 accumulator功能必须是associative功能。
    
    这是一个terminal operation 。
    API Note:
    总和，最小，最大和平均都是减少的特殊情况。一个数字流可以表示为：
    long sum = integers.reduce(0, (a, b) -> a+b);
    或更紧凑：
    long sum = integers.reduce(0, Long::sum);
    
    尽管与简单地将循环中的总体变量相比，这可能看起来更为迂回的方式进行，但减少操作更平稳地并行化，而不需要额外的同步，并大大降低了数据竞争的风险。
    参数
    
    identity - 积累函数的身份值
    
    op -一个 associative ， non-interfering ， stateless功能组合两个值
    
    结果
    
    减少的结果
    
    另请参见：
    
    sum() ， min() ， max() ， average()
  - reduce
```
OptionalLong reduce(LongBinaryOperator op)
```
    使用associative累积功能对此流的元素执行reduction ，并返回描述减小值的OptionalLong （如果有）。这相当于：
```
   boolean foundAny = false; long result = null; for (long element : this stream) { if (!foundAny) { foundAny = true; result = element; } else result = accumulator.applyAsLong(result, element); } return foundAny ? OptionalLong.of(result) : OptionalLong.empty();  
```
    但不限于顺序执行。
    accumulator功能必须是associative功能。
    
    这是一个terminal operation 。
    参数
    
    op -一个 associative ， non-interfering ， stateless功能组合两个值
    
    结果
    
    减少的结果
    
    另请参见：
    
    reduce(long, LongBinaryOperator)
  - collect
```
<R> R collect(Supplier<R> supplier,
              ObjLongConsumer<R> accumulator,
              BiConsumer<R,R> combiner)
```
    对此流的元素执行mutable reduction操作。一个可变的减少是其中所述减小的值是一个可变的结果容器，如ArrayList ，和元素通过更新通过替换结果的结果，而不是状态并入。这产生的结果相当于：
```
   R result = supplier.get(); for (long element : this stream) accumulator.accept(result, element); return result;  
```
    像reduce(long, LongBinaryOperator)一样， collect操作可以并行化，而不需要额外的同步。
    
    这是一个terminal operation 。
    参数类型
    
    R - 结果的类型
    
    参数
    
    supplier - 创建新结果容器的函数。对于并行执行，可以多次调用此函数，并且每次都必须返回一个新的值。
    
    accumulator -一个 associative ， non-interfering ， stateless功能用于将一个额外的元件到结果
    
    combiner -一个 associative ， non-interfering ， stateless功能用于组合两个值，它必须与蓄能器功能兼容
    
    结果
    
    减少的结果
    
    另请参见：
    
    Stream.collect(Supplier, BiConsumer, BiConsumer)
  - sum
```
long sum()
```
    返回此流中元素的总和。这是一个reduction的特殊情况，相当于：
```
   return reduce(0, Long::sum);  
```
    这是一个terminal operation 。
    结果
    
    这个流中元素的总和
  - min
```
OptionalLong min()
```
    返回OptionalLong此流的最小元素的OptionalLong，如果此流为空，则返回一个空的可选项。这是一个reduction的特殊情况，相当于：
```
   return reduce(Long::min);  
```
    这是一个terminal operation 。
    结果
    
    一个 OptionalLong此流的最小元素的 OptionalLong如果流为空， OptionalLong
  - max
```
OptionalLong max()
```
    返回OptionalLong此流的最大元素的OptionalLong，如果此流为空，则返回一个空的可选项。这是一个reduction的特殊情况，相当于：
```
   return reduce(Long::max);  
```
    这是一个terminal operation 。
    结果
    
    一个 OptionalLong此流的最大元素的 OptionalLong如果流为空， OptionalLong
  - count
```
long count()
```
    返回此流中的元素数。这是一个reduction的特殊情况，相当于：
```
   return map(e -> 1L).sum();  
```
    这是一个terminal operation 。
    结果
    
    这个流中元素的数量
  - average
```
OptionalDouble average()
```
    返回OptionalDouble此流的元素的算术平均值的OptionalDouble，如果此流为空，则返回一个空的可选项。这是一个reduction的特殊情况。
    这是一个terminal operation 。
    
    结果
    
    一个 OptionalDouble此流的平均元素的OptionalDouble，如果流为空，则为空可选
  - summaryStatistics
```
LongSummaryStatistics summaryStatistics()
```
    返回一个LongSummaryStatistics描述有关此流的元素的各种摘要数据。这是一个reduction的特例。
    这是一个terminal operation 。
    
    结果
    
    一个 LongSummaryStatistics描述了关于这个流的元素的各种总结数据
  - anyMatch
```
boolean anyMatch(LongPredicate predicate)
```
    返回此流的任何元素是否与提供的谓词匹配。如果不需要确定结果，则不能评估所有元素上的谓词。如果流为空，则false返回和谓语不评估。
    这是一个short-circuiting terminal operation 。
    
    API Note:
    
    该方法评估了流的元素（对于某些x P（x））的谓词的存在量化。
    
    参数
    
    predicate - a non-interfering，stateless 谓词适用于此流的元素
    
    结果
    
    true如果流的任何元素与提供的谓词匹配，否则为 false
  - allMatch
```
boolean allMatch(LongPredicate predicate)
```
    返回此流的所有元素是否与提供的谓词匹配。如果不需要确定结果，则不能评估所有元素上的谓词。如果流为空，则true返回和谓语不评估。
    这是一个short-circuiting terminal operation 。
    
    API Note:
    
    该方法评估了流的元素（对于所有x P（x））的谓词的通用量化 。如果流是空的，量化据说是空洞地满意 ，始终是true （不管的P（X））。
    
    参数
    
    predicate -一个 non-interfering ， stateless谓词适用于该流的元素
    
    结果
    
    true如果流的所有元素匹配提供的谓词或流是空的，否则 false
  - noneMatch
```
boolean noneMatch(LongPredicate predicate)
```
    返回此流的元素是否与提供的谓词匹配。如果不需要确定结果，则不能评估所有元素上的谓词。如果流为空，则true返回和谓语不评估。
    这是一个short-circuiting terminal operation 。
    
    API Note:
    
    此方法评估通过该流中的元素的否定谓词的通用定量 （对于所有的x〜P（X））。如果流是空的，那么量化被认为是空虚的，并且始终是true ，不管P（x）如何。
    
    参数
    
    predicate - a non-interfering，stateless 谓词适用于此流的元素
    
    结果
    
    true如果流中没有元素匹配提供的谓词或流是空的，否则 false
  - findFirst
```
OptionalLong findFirst()
```
    返回描述此流的第一个元素的OptionalLong如果流为空，则返回一个空的OptionalLong 。如果流没有遇到顺序，则可能会返回任何元素。
    这是一个short-circuiting terminal operation 。
    
    结果
    
    一个 OptionalLong此流的第一个元素的 OptionalLong如果流为空， OptionalLong
  - findAny
```
OptionalLong findAny()
```
    返回描述流的一些元素的OptionalLong如果流为空，则返回一个空的OptionalLong 。
    这是一个short-circuiting terminal operation 。
    
    这个操作的行为显然是不确定的; 可以自由选择流中的任何元素。这是为了允许并行操作中的最大性能; 成本是同一来源上的多次调用可能不会返回相同的结果。（如果需要稳定的结果，请改用findFirst() ）
    
    结果
    
    一个 OptionalLong此流的某些元素的 OptionalLong如果流为空， OptionalLong
    
    另请参见：
    
    findFirst()
  - asDoubleStream
```
DoubleStream asDoubleStream()
```
    返回一个DoubleStream由该流中的元素，转换为double 。
    这是一个intermediate operation 。
    
    结果
    
    一个 DoubleStream由这个流的元素组成，转换为 double
  - boxed
```
Stream<Long> boxed()
```
    返回一个Stream由该流的盒装到所述的元件，每个的Long 。
    这是一个intermediate operation 。
    
    结果
    
    一个 Stream一致的这个流的元素，每个盒装到 Long
  - sequential
```
LongStream sequential()
```
    说明从界面： BaseStream复制
    
    返回顺序的等效流。可能返回自己，因为流已经是顺序的，或者因为底层流状态被修改为顺序的。
    这是一个intermediate operation 。
    
    Specified by:
    
    sequential在界面 BaseStream<Long,LongStream>
    
    结果
    
    顺序流
  - parallel
```
LongStream parallel()
```
    说明从界面： BaseStream复制
    
    返回平行的等效流。可能会返回自己，因为流已经是并行的，或者因为底层流状态被修改为并行。
    这是一个intermediate operation 。
    
    Specified by:
    
    parallel在界面 BaseStream<Long,LongStream>
    
    结果
    
    并行流
  - iterator
```
PrimitiveIterator.OfLong iterator()
```
    说明从界面： BaseStream复制
    
    返回此流的元素的迭代器。
    这是一个terminal operation 。
    
    Specified by:
    
    iterator在界面 BaseStream<Long,LongStream>
    
    结果
    
    该流的元素迭代器
  - spliterator
```
Spliterator.OfLong spliterator()
```
    说明从界面： BaseStream复制
    
    返回此流的元素的拼接器。
    这是一个terminal operation 。
    
    Specified by:
    
    spliterator在界面 BaseStream<Long,LongStream>
    
    结果
    
    该流的元素拼接器
  - builder
```
static LongStream.Builder builder()
```
    返回一个 LongStream的生成器。
    
    结果
    
    流构建器
  - empty
```
static LongStream empty()
```
    返回一个空的顺序 LongStream 。
    
    结果
    
    一个空的顺序流
  - of
```
static LongStream of(long t)
```
    返回包含单个元素的顺序 LongStream 。
    
    参数
    
    t - 单一元素
    
    结果
    
    单例顺序流
  - of
```
static LongStream of(long... values)
```
    返回其元素是指定值的顺序排序流。
    
    参数
    
    values - 新流的元素
    
    结果
    
    新的流
  - iterate
```
static LongStream iterate(long seed,
                          LongUnaryOperator f)
```
    返回有序无限连续LongStream由函数的迭代应用产生f至初始元素seed ，产生Stream包括seed ， f(seed) ， f(f(seed)) ，等
    第一元件（位置0在） LongStream将是提供seed 。对于n > 0 ，位置n的元素将是将函数f应用于位置n - 1的元素的n - 1 。
    
    参数
    
    seed - 初始元素
    
    f - 要应用于上一个元素以生成新元素的函数
    
    结果
    
    一个新的顺序 LongStream
  - generate
```
static LongStream generate(LongSupplier s)
```
    返回无限顺序无序流，其中每个元素由提供的LongSupplier 。这适合于产生恒定流，随机元素流等
    
    参数
    
    s -所述 LongSupplier为生成的元素
    
    结果
    
    一个新的无限顺序无序 LongStream
  - range
```
static LongStream range(long startInclusive,
                        long endExclusive)
```
    返回有序的顺序 LongStream从 startInclusive （含）至 endExclusive通过增量步骤（独家） 1 。
    API Note:
    可以使用for循环顺序地产生递增值的等效序列，如下所示：
    
    for (long i = startInclusive; i < endExclusive ; i++) { ... }
    参数
    
    startInclusive - （含）初始值
    
    endExclusive - 专属上限
    
    结果
    
    LongStream为 long元素的 long
  - rangeClosed
```
static LongStream rangeClosed(long startInclusive,
                              long endInclusive)
```
    返回有序顺序 LongStream从 startInclusive （含）至 endInclusive通过的递增步长（含） 1 。
    API Note:
    可以使用for循环顺序地产生递增值的等效序列，如下所示：
    
    for (long i = startInclusive; i <= endInclusive ; i++) { ... }
    参数
    
    startInclusive - （含）初始值
    
    endInclusive - 包含上限
    
    结果
    
    顺序 LongStream为的范围 long元件
  - concat
```
static LongStream concat(LongStream a,
                         LongStream b)
```
    创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。如果两个输入流都被排序，则生成的流被排序，并且如果任何一个输入流是并行的，则并行。当结果流关闭时，调用两个输入流的关闭处理程序。
    
    Implementation Note:
    
    在重复连接构建流时要小心。访问深层级流的元素可能导致深层呼叫链，甚至可能导致StackOverflowException 。
    
    参数
    
    a - 第一个流
    
    b - 第二个流
    
    结果
    
    两个输入流的并置

Interface LongStream

Nested Class Summary

方法摘要

Methods inherited from interface java.util.stream.BaseStream

方法详细信息

filter

map

mapToObj

mapToInt

mapToDouble

flatMap

distinct

sorted

peek

limit

skip

forEach

forEachOrdered

toArray

reduce

reduce

collect

sum

min

max

count

average

summaryStatistics

anyMatch

allMatch

noneMatch

findFirst

findAny

asDoubleStream

boxed

sequential

parallel

iterator

spliterator

builder

empty

of

of

iterate

generate

range

rangeClosed

concat