DoubleStream (Java Platform SE 8 )

All Superinterfaces:

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

方法摘要

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

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

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

Interface DoubleStream

Nested Class Summary

方法摘要

Methods inherited from interface java.util.stream.BaseStream

方法详细信息

filter

map

mapToObj

mapToInt

mapToLong

flatMap

distinct

sorted

peek

limit

skip

forEach

forEachOrdered

toArray

reduce

reduce

collect

sum

min

max

count

average

summaryStatistics

anyMatch

allMatch

noneMatch

findFirst

findAny

boxed

sequential

parallel

iterator

spliterator

builder

empty

of

of

iterate

generate

concat