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

嵌套类汇总

嵌套类

变量和类型接口描述

static interface DoubleStream.Builder
DoubleStream可变构建器。

方法摘要

所有方法静态方法实例方法抽象方法 Default Methods
变量和类型	方法	描述
`boolean`	`allMatch(DoublePredicate predicate)`	返回此流的所有元素是否与提供的谓词匹配。
`boolean`	`anyMatch(DoublePredicate predicate)`	返回此流的任何元素是否与提供的谓词匹配。
`OptionalDouble`	`average()`	返回描述此流元素的算术平均值的 `OptionalDouble` ，如果此流为空，则返回空可选。
`Stream<Double>`	`boxed()`	返回 `Stream`其中包含此流的元素， `Double`为 `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()`	返回由此流的不同元素组成的流。
`default DoubleStream`	`dropWhile(DoublePredicate predicate)`	如果对此流进行排序，则返回在删除与给定谓词匹配的元素的最长前缀之后由该流的其余元素组成的流。
`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, DoublePredicate hasNext, DoubleUnaryOperator next)`	返回通过将给定的 `next`函数迭代应用于初始元素 `DoubleStream`产生的顺序有序 `DoubleStream` ，条件是满足给定的 `hasNext`谓词。
`static DoubleStream`	`iterate(double seed, DoubleUnaryOperator f)`	返回有序无限连续 `DoubleStream`由函数的迭代应用产生 `f`到初始元素 `seed` ，产生 `Stream`组成的 `seed` ， `f(seed)` ， `f(f(seed))`等
`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`	`min()`	返回描述此流的最小元素的 `OptionalDouble` ，如果此流为空，则返回空的OptionalDouble。
`boolean`	`noneMatch(DoublePredicate predicate)`	返回此流的元素是否与提供的谓词匹配。
`static DoubleStream`	`of(double t)`	返回包含单个元素的顺序 `DoubleStream` 。
`static DoubleStream`	`of(double... values)`	返回其元素为指定值的顺序有序流。
`DoubleStream`	`peek(DoubleConsumer action)`	返回由此流的元素组成的流，另外在每个元素上执行提供的操作，因为元素是从结果流中消耗的。
`double`	`reduce(double identity, DoubleBinaryOperator op)`	使用提供的标识值和 associative累积函数对此流的元素执行 reduction ，并返回减小的值。
`OptionalDouble`	`reduce(DoubleBinaryOperator op)`	使用 associative累积功能对此流的元素执行 reduction ，并返回描述减少值的 `OptionalDouble` （如果有）。
`DoubleStream`	`skip(long n)`	在丢弃流的第一个 `n`元素后，返回由此流的其余元素组成的流。
`DoubleStream`	`sorted()`	以排序顺序返回由此流的元素组成的流。
`double`	`sum()`	返回此流中元素的总和。
`DoubleSummaryStatistics`	`summaryStatistics()`	返回 `DoubleSummaryStatistics`描述有关此流元素的各种摘要数据。
`default DoubleStream`	`takeWhile(DoublePredicate predicate)`	如果对此流进行排序，则返回一个流，该流包含从此流中获取的与给定谓词匹配的最长元素前缀。
`double[]`	`toArray()`	返回包含此流的元素的数组。

声明方法的接口 java.util.stream.BaseStream
close, isParallel, iterator, onClose, parallel, sequential, spliterator, 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();
    
    如果流实现能够优化某些或所有元素的生成（例如使用短路操作，如findFirst ，或者在findFirst中描述的示例），则不会为这些元素调用该操作。
    
    参数
    
    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()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。
    
    参数
    
    maxSize - 流应限制的元素数
    
    结果
    
    新流
    
    异常
    
    IllegalArgumentException - 如果 maxSize为负数
  - skip
```
DoubleStream skip(long n)
```
    在丢弃流的第一个n元素后，返回由此流的其余元素组成的流。如果此流包含少于n元素，则将返回空流。
    这是一个stateful intermediate operation 。
    
    API Note:
    
    虽然skip()通常是顺序流管道上的廉价操作，但在有序并行管道上可能相当昂贵，特别是对于大值n ，因为skip(n)被限制为不仅跳过任何n个元素，而是跳过遭遇顺序中的前n个元素。使用无序流源（例如generate(DoubleSupplier) ）或去除所述排序约束与BaseStream.unordered()可能导致显著加速比skip()在并行管线，如果情况许可的语义。如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与skip()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。
    
    参数
    
    n - 要跳过的前导元素的数量
    
    结果
    
    新流
    
    异常
    
    IllegalArgumentException - 如果 n为负数
  - takeWhile
```
default DoubleStream takeWhile(DoublePredicate predicate)
```
    如果对此流进行排序，则返回一个流，该流包含从此流中获取的与给定谓词匹配的最长元素前缀。否则，如果此流是无序的，则返回由从此流中获取的与给定谓词匹配的元素子集组成的流。
    如果对此流进行排序，则最长前缀是与该给定谓词匹配的该流的连续元素序列。序列的第一个元素是此流的第一个元素，紧跟在序列的最后一个元素之后的元素与给定的谓词不匹配。
    
    如果此流是无序的，并且此流的某些（但不是所有）元素与给定谓词匹配，则此操作的行为是不确定的; 它可以自由地获取匹配元素的任何子集（包括空集）。
    
    如果此流的所有元素与给定谓词匹配，则此流是有序还是无序，无论此操作是否接受所有元素（结果与输入相同），或者如果流的任何元素都不匹配给定谓词，则没有元素被采取（结果是一个空流）。
    
    这是一个short-circuiting stateful intermediate operation 。
    
    API Note:
    
    虽然takeWhile()通常是顺序流管道上的廉价操作，但在有序并行管道上它可能非常昂贵，因为操作被约束为不仅返回任何有效前缀，而是返回遭遇顺序中元素的最长前缀。使用无序流源（例如generate(DoubleSupplier) ）或去除所述排序约束与BaseStream.unordered()可能导致显著加速比takeWhile()在并行管线，如果情况许可的语义。如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与takeWhile()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。
    
    实现要求：
    
    默认实现获取此流的spliterator ，包装该spliterator以便在遍历时支持此操作的语义，并返回与包装的spliterator关联的新流。返回的流保留该流的执行特征（即根据BaseStream.isParallel()的并行或顺序执行），但是包装的分裂器可以选择不支持分割。返回的流关闭后，将调用返回的流和此流的关闭处理程序。
    
    参数
    
    predicate -一个 non-interfering ， stateless谓词适用于元素，以确定元素的最长前缀。
    
    结果
    
    新流
    
    从以下版本开始：
    
    9
  - dropWhile
```
default DoubleStream dropWhile(DoublePredicate predicate)
```
    如果对此流进行排序，则返回在删除与给定谓词匹配的元素的最长前缀之后由该流的其余元素组成的流。否则，如果此流是无序的，则返回在删除与给定谓词匹配的元素子集之后由该流的其余元素组成的流。
    如果对此流进行排序，则最长前缀是与该给定谓词匹配的该流的连续元素序列。序列的第一个元素是此流的第一个元素，紧跟在序列的最后一个元素之后的元素与给定的谓词不匹配。
    
    如果此流是无序的，并且此流的某些（但不是所有）元素与给定谓词匹配，则此操作的行为是不确定的; 它可以自由地删除匹配元素的任何子集（包括空集）。
    
    如果此流的所有元素与给定谓词匹配，则该流是有序还是无序，无论该操作是否丢弃所有元素（结果是空流），或者如果流的任何元素都不匹配给定谓词，则不会丢弃任何元素（结果与输入相同）。
    
    这是一个stateful intermediate operation 。
    
    API Note:
    
    虽然dropWhile()通常是顺序流管道上的廉价操作，但在有序并行管道上它可能非常昂贵，因为操作被约束为不仅返回任何有效前缀，而是返回遭遇顺序中元素的最长前缀。使用无序流源（例如generate(DoubleSupplier) ）或去除所述排序约束与BaseStream.unordered()可能导致显著加速比dropWhile()在并行管线，如果情况许可的语义。如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与dropWhile()在并行管线，在切换到的顺序执行与BaseStream.sequential()可以提高性能。
    
    实现要求：
    
    默认实现获取此流的spliterator ，包装该spliterator以便在遍历时支持此操作的语义，并返回与包装的spliterator关联的新流。返回的流保留该流的执行特征（即根据BaseStream.isParallel()并行或顺序执行），但是包装的分裂器可以选择不支持分割。返回的流关闭后，将调用返回的流和此流的关闭处理程序。
    
    参数
    
    predicate -一个 non-interfering ， stateless谓词适用于元素，以确定元素的最长前缀。
    
    结果
    
    新流
    
    从以下版本开始：
    
    9
  - 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);
    然而，由于浮点求和不精确，上述代码不一定等于通过该方法完成的求和计算。
    浮点和的值是输入值以及加法运算的顺序的函数。故意不定义该方法的加法运算的顺序以允许实现灵活性以提高计算结果的速度和准确性。特别地，该方法可以使用补偿求和或其他技术来实现，以减少数值和与double值的简单求和相比的误差界限。由于未指定的操作顺序和使用不同求和方案的可能性，该方法的输出可能在相同的输入元素上变化。
    
    各种条件可导致计算非有限和。即使所有被求和的元素都是有限的，也会发生这种情况。如果任何元素是非有限的，则总和将是非有限的：
    
    如果任何元素是NaN，则最终总和将是NaN。
    
    如果元素包含一个或多个无穷大，则总和将为无穷大或NaN。
    
    如果元素包含符号相反的无穷大，则总和将为NaN。
    
    如果元素包含一个符号的无穷大且中间和溢出到相反符号的无穷大，则总和可以是NaN。
    
    有限值的中间和可能溢出到相反的有符号无穷大; 如果发生这种情况，即使元素都是有限的，最终的总和也是NaN。如果所有元素都为零，则不保证在最终总和中保留零符号。
    这是一个terminal operation 。
    API Note:
    
    通过增加绝对量值排序的元素往往会产生更准确的结果。
    
    结果
    
    此流中元素的总和
  - min
```
OptionalDouble min()
```
    返回描述此流的最小元素的OptionalDouble ，如果此流为空，则返回空的OptionalDouble。如果任何流元素是NaN，则最小元素将是Double.NaN 。与数值比较运算符不同，此方法将负零视为严格小于正零。这是reduction的特例，相当于：
    return reduce(Double::min);
    
    这是一个terminal operation 。
    结果
    
    包含此流的最小元素的 OptionalDouble ，如果流为空，则为空可选
  - max
```
OptionalDouble max()
```
    返回描述此流的最大元素的OptionalDouble ，如果此流为空，则返回空的OptionalDouble。如果任何流元素是NaN，则最大元素将是Double.NaN 。与数值比较运算符不同，此方法将负零视为严格小于正零。这是reduction的特例，相当于：
    return reduce(Double::max);
    
    这是一个terminal operation 。
    结果
    
    包含此流的最大元素的 OptionalDouble ，如果流为空，则为空可选
  - count
```
long count()
```
    返回此流中元素的数量。这是reduction的特例，相当于：
    return mapToLong(e -> 1L).sum();
    
    这是一个terminal operation 。
    API Note:
    
    如果实现可以直接从流源计算计数，则实现可以选择不执行流管道（顺序地或并行地）。在这种情况下，不会遍历任何源元素，也不会评估中间操作。除了诸如调试之类的无害情况之外，强烈不鼓励具有副作用的行为参数可能会受到影响。例如，请考虑以下流：
    DoubleStream s = DoubleStream.of(1, 2, 3, 4); long count = s.peek(System.out::println).count();
    流源所涵盖的元素数量是已知的，并且中间操作peek不会从流中注入或移除元素（对于flatMap或filter操作可能是这种情况）。因此，计数为4，并且不需要执行管道，并且作为副作用，打印出元素。
    
    结果
    
    此流中的元素数
  - average
```
OptionalDouble average()
```
    返回描述此流元素的算术平均值的OptionalDouble ，如果此流为空，则返回空可选。
    计算的平均值可以在数值上变化，并具有计算总和的特殊情况行为; 有关详细信息，请参阅sum() 。
    
    平均值是reduction的特例。
    
    这是一个terminal operation 。
    
    API Note:
    
    通过增加绝对量值排序的元素往往会产生更准确的结果。
    
    结果
    
    包含此流的平均元素的 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如果流是空
  - findAny
```
OptionalDouble findAny()
```
    返回OptionalDouble描述流的一些元件，或一个空OptionalDouble如果流是空的。
    这是一个short-circuiting terminal operation 。
    
    此操作的行为明确是不确定的; 可以自由选择流中的任何元素。这是为了在并行操作中实现最大性能; 成本是同一源上的多次调用可能不会返回相同的结果。（如果需要稳定的结果，请改用findFirst()。）
    
    结果
    
    一个 OptionalDouble描述该流的一些元件，或一个空 OptionalDouble如果流是空
    
    另请参见：
    
    findFirst()
  - boxed
```
Stream<Double> boxed()
```
    返回Stream其中包含此流的元素， Double为Double 。
    这是一个intermediate operation 。
    
    结果
    
    a Stream此流的元素一致，每个都 Double
  - 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 。
    
    施加的作用f为一个元件happens-before施加的作用f用于随后的元件。对于任何给定元素，可以在库选择的任何线程中执行操作。
    
    参数
    
    seed - 初始元素
    
    f - 要应用于上一个元素以生成新元素的函数
    
    结果
    
    一个新的顺序 DoubleStream
  - iterate
```
static DoubleStream iterate(double seed,
                            DoublePredicate hasNext,
                            DoubleUnaryOperator next)
```
    返回通过将给定的next函数迭代应用于初始元素DoubleStream生成的顺序有序DoubleStream ，条件是满足给定的hasNext谓词。一旦hasNext谓词返回false，流就会终止。
    DoubleStream.iterate应该生成与相应的for循环生成的元素序列相同的元素：
    
    for (double index=seed; hasNext.test(index); index = next.applyAsDouble(index)) { ... }
    
    如果hasNext谓词不保留种子值，则结果序列可能为空。否则，第一个元素将是提供的seed值，下一个元素（如果存在）将是将next函数应用于seed值的结果，依此类推，直到hasNext谓词指示流应终止。
    
    将hasNext谓词应用于元素happens-before将next函数应用于该元素的操作的操作。对一个元素应用next函数的操作发生在将hasNext谓词应用于后续元素的操作之前。对于任何给定元素，可以在库选择的任何线程中执行动作。
    参数
    
    seed - 初始元素
    
    hasNext - 应用于元素以确定流何时必须终止的谓词。
    
    next - 要应用于前一个元素以生成新元素的函数
    
    结果
    
    一个新的顺序 DoubleStream
    
    从以下版本开始：
    
    9
  - generate
```
static DoubleStream generate(DoubleSupplier s)
```
    返回无限顺序无序流，其中每个元素由提供的DoubleSupplier生成。这适用于生成恒定流，随机元素流等。
    
    参数
    
    s - 生成的元素的 DoubleSupplier
    
    结果
    
    一个新的无限顺序无序 DoubleStream
  - concat
```
static DoubleStream concat(DoubleStream a,
                           DoubleStream b)
```
    创建一个延迟连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。如果两个输入流都是有序的，则对所得到的流进行排序，如果任一输入流是并行的，则对其进行并行。关闭结果流时，将调用两个输入流的关闭处理程序。
    此方法对两个输入流进行操作，并将每个流绑定到其源。结果，对输入流源的后续修改可能不会反映在级联流结果中。
    API Note:
    
    为了保留优化机会，此方法将每个流绑定到其源，并仅接受两个流作为参数。例如，如果已知每个输入流源的确切大小，则可以计算级联流源的确切大小。要在不绑定的情况下连接更多流，或者不对此方法进行嵌套调用，请尝试使用标识函数创建流和平面映射流，例如：
    DoubleStream concat = Stream.of(s1, s2, s3, s4).flatMapToDouble(s -> s);
    
    Implementation Note:
    
    从重复串联构造流时要小心。访问深度连接的流的元素可能会导致深度调用链，甚至StackOverflowError 。
    
    参数
    
    a - 第一个流
    
    b - 第二个流
    
    结果
    
    the concatenation of the two input streams

Interface DoubleStream

嵌套类汇总

方法摘要

声明方法的接口 java.util.stream.BaseStream

方法详细信息

filter

map

mapToObj

mapToInt

mapToLong

flatMap

distinct

sorted

peek

limit

skip

takeWhile

dropWhile

forEach

forEachOrdered

toArray

reduce

reduce

collect

sum

min

max

count

average

summaryStatistics

anyMatch

allMatch

noneMatch

findFirst

findAny

boxed

builder

empty

of

of

iterate

iterate

generate

concat