Module  java.base
软件包  java.util.stream

Interface DoubleStream

    • 方法详细信息

      • mapToObj

        <U> Stream<U> mapToObj​(DoubleFunction<? extends U> mapper)
        返回一个对象值Stream其中包含将给定函数应用于此流的元素的结果。

        这是一个intermediate operation 。

        参数类型
        U - 新流的元素类型
        参数
        mapper -一个 non-interfering ， stateless函数应用到每个元件
        结果
        新的流

      • 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 ，或在所描述的示例count() ），动作将不被调用这些元素。

        参数
        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元素，则将返回一个空流。

        这是一个stateful intermediate operation 。

        API Note:
        虽然skip()通常是顺序流管线上的廉价操作，但是在有序的并行流水线上可能相当昂贵，特别是对于n大值，因为skip(n)被限制为不仅跳过任何n个元素，而且会遇到顺序的前n个元素。 如果您的情况允许，则使用无序流源（例如generate(DoubleSupplier) ）或使用BaseStream.unordered()删除排序约束可能会导致并行流水线显着加速skip() 。 如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与skip()在并行管线，在切换到的顺序执行与sequential()可以提高性能。
        参数
        n - 要跳过的主要元素的数量
        结果
        新的流
        异常
        IllegalArgumentException - 如果 n为负数

      • takeWhile

        default DoubleStream takeWhile​(DoublePredicate predicate)
        如果此流被排序，则返回一个流，该流由与此给定谓词匹配的从该流获取的元素的最长前缀组成。 否则返回，如果该流是无序的，则由从与该给定谓词匹配的该流中取得的元素的子集组成的流。

        如果该流被排序，则最长的前缀是与给定谓词匹配的该流的连续的元素序列。 序列的第一个元素是此流的第一个元素，并且紧跟该序列的最后一个元素的元素与给定谓词不匹配。

        如果该流是无序的，并且该流的一些（但不是全部）元素与给定的谓词匹配，则该操作的行为是非确定性的; 可以自由地采取匹配元素的任何子集（包括空集）。

        独立于该流是否被排序或无序，如果此流的所有元素与给定谓词匹配，则此操作将采用所有元素（结果与输入相同），或者如果流的元素与给定谓词匹配，则没有元素被采取（结果是一个空的流）。

        这是一个short-circuiting stateful intermediate operation 。

        API Note:
        虽然takeWhile()通常是顺序流管线上的廉价操作，但是在有序并行流水线上可能是相当昂贵的，因为操作被限制为不仅返回任何有效前缀，而且返回遇到顺序中元素的最长前缀。 如果您的情况允许，则使用无序流源（如generate(DoubleSupplier) ）或使用BaseStream.unordered()删除排序约束可能会导致并行流水线显着加速takeWhile() 。 如果具有遭遇顺序的一致性是必须的，并且遇到性能或存储器利用率差与takeWhile()在并行管线，在切换到的顺序执行与sequential()可以提高性能。
        实现要求：
        默认实现获得此流的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()在并行管线，在切换到的顺序执行与sequential()可以提高性能。
        实现要求：
        默认实现获取此流的spliterator ，包装该分割器，以便在遍历时支持此操作的语义，并返回与包装拼接器相关联的新流。 返回的流保留此流的执行特性（即按照BaseStream.isParallel()并行或顺序执行），但是包装的拼接器可能选择不支持拆分。 当返回的流关闭时，将调用返回的流和此流的关闭处理程序。
        参数
        predicate -一个 non-interfering ， stateless谓词适用于元素，以确定元素的最长前缀。
        结果
        新的流
        从以下版本开始：
        9

      • forEach

        void forEach​(DoubleConsumer action)
        对此流的每个元素执行操作。

        这是一个terminal operation 。

        对于并行流管道，此操作不能保证遵守流的遇到顺序，因为这样做会牺牲并行性的好处。 对于任何给定的元素，动作可以在图书馆选择的任何时间和任何线索中执行。 如果操作访问共享状态，则负责提供所需的同步。

        参数
        action - 一个 non-interfering对元素执行的操作

      • 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()

      • 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 。

        这是一个intermediate operation 。

        结果
        一个 Stream一致的这个流的元素，每个盒装到一个 Double

      • 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 。

        施加的作用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-loop相同的元素序列： 

           for (double index=seed; hasNext.test(index); index = next.applyAsDouble(index)) { ... }

        如果hasNext谓词不持有种子值，则结果序列可能为空。 否则第一个元素将是提供的seed值，下一个元素（如果存在）将是将next函数应用于seed值的结果，等等，直到hasNext谓词指示流应该终止。

        将hasNext谓词应用于元素happens-before的操作将next函数应用于该元素。 在为后续元素应用hasNext谓词的动作之前 ， 会发生一个元素应用next函数的动作。 对于任何给定的元素，可以在库选择的任何线程中执行一个动作。

        参数
        seed - 初始元素
        hasNext - 应用于元素以确定流何时终止的谓词。
        next - 要应用于前一个元素以生成新元素的函数
        结果
        一个新的顺序 DoubleStream
        从以下版本开始：
        9

      • generate

        static DoubleStream generate​(DoubleSupplier s)
        返回无限顺序无序流，其中每个元素由提供的DoubleSupplier生成。 这适合于产生恒定流，随机元素流等
        参数
        s - 用于生成元素的 DoubleSupplier
        结果
        一个新的无限顺序无序 DoubleStream

      • concat

        static DoubleStream concat​(DoubleStream a,
                           DoubleStream b)
        创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。 如果两个输入流都被排序，则生成的流被排序，并且如果任何一个输入流是并行的，则并行。 当结果流关闭时，调用两个输入流的关闭处理程序。
        Implementation Note:
        在重复连接构建流时要小心。 访问深层级流的元素可能导致深层调用链，甚至可能导致StackOverflowError 。
        参数
        a - 第一个流
        b - 第二个流
        结果
        两个输入流的并置