DoubleStream (Java Platform SE 8 )

All Superinterfaces:

AutoCloseable， BaseStream < Double， DoubleStream >
```
public interface DoubleStream
extends BaseStream<Double,DoubleStream>
```
支持序列和并行聚合操作的原始双值元素序列。这是 Stream的 double原始化。
下面的例子说明了如何使用Stream和DoubleStream聚合运算，计算的红色小部件的重量的总和：
```
     double sum = widgets.stream()
                         .filter(w -> w.getColor() == RED)
                         .mapToDouble(w -> w.getWeight())
                         .sum();
 
```
看到 Stream为流，额外的规范 java.util.stream包文档类文件流操作，流管道，和并行性。
从以下版本开始：

一点八

另请参见：

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`描述此流的元素的算术平均值，或一个空如果此流是空的。
`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`由最初的一元 `seed`函数的 `f`迭代应用产生的，产生一个由 `seed`， `f(seed)`， `f(f(seed))` `Stream`，等。
`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`	`min()` 返回一个 `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)` 对这一 reduction流元素，使用 associative累积函数，并返回一个 `OptionalDouble`描述价值减少，如果任何。
`double`	`reduce(double identity, DoubleBinaryOperator op)` 对这一 reduction流元素，使用提供的价值认同和 associative累积函数，返回值减少。
`DoubleStream`	`sequential()` 返回一个连续的等效流。
`DoubleStream`	`skip(long n)` 返回一个包含此流的其余部分丢弃的流的第一 `n`元素后流。
`DoubleStream`	`sorted()` 返回按排序顺序由该流的元素组成的流。
`Spliterator.OfDouble`	`spliterator()` 返回一个对该流的元素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元素然后将返回空流。
    这是一个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)
```
    对这一 reduction流元素，使用提供的价值认同和 associative累积函数，返回值减少。这相当于：
```
     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)
```
    对这一 reduction流元素，使用 associative累积函数，并返回一个 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值求和减少误差的数值和实施。
    
    这是一个terminal operation。
    API Note:
    
    元素排序通过增加绝对幅度往往会产生更准确的结果。
    
    结果
    
    此流中元素的和
  - min
```
OptionalDouble min()
```
    返回一个 OptionalDouble描述该流的最小元素，或一个空的optionaldouble如果流是空的。最小的元素将 Double.NaN如果任何流元是楠。与数值比较运算符，这种方法认为负零是严格小于正零。这是一个 reduction特例，相当于：
```
     return reduce(Double::min);
 
```
    这是一个terminal operation。
    结果
    
    一个 OptionalDouble包含此流的最小元素，或一个空的可选如果流是空的
  - max
```
OptionalDouble max()
```
    返回一个 OptionalDouble描述此流的最大元素，或一个空的optionaldouble如果流是空的。最大的元素将被 Double.NaN如果任何流元是楠。与数值比较运算符，这种方法认为负零是严格小于正零。这是一个 reduction特例，相当于：
```
     return reduce(Double::max);
 
```
    这是一个terminal operation。
    结果
    
    一个 OptionalDouble包含此流的最大元素，或一个空的可选如果流是空的
  - count
```
long count()
```
    返回此流中元素的计数。这是一个 reduction特例，相当于：
```
     return mapToLong(e -> 1L).sum();
 
```
    这是一个terminal operation。
    结果
    
    该流中元素的计数
  - average
```
OptionalDouble average()
```
    返回一个 OptionalDouble描述此流的元素的算术平均值，或一个空如果此流是空的。如果任何一个记录的值是一个南或总和是在任何一点一个楠，那么平均将是楠。
    返回的平均值可能会有所不同，这取决于记录的值的顺序。这种方法可以使用补偿总和或其他技术来降低误差在用于计算平均numerical 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
  - 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
    
    返回一个对该流的元素spliterator。
    这是一个terminal operation。
    
    Specified by:
    
    spliterator 接口 BaseStream<Double,DoubleStream>
    
    结果
    
    该流的元素spliterator
  - 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由最初的一元 seed函数的 f迭代应用产生的，产生一个由 seed， f(seed)， f(f(seed)) Stream，等
    第一单元（位置0）在DoubleStream将提供seed。对于n > 0，位置n元素，将在位置n - 1元素的应用功能f结果。
    
    参数
    
    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 -二流
    
    结果
    
    这两个输入流连接

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

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