- 所有父级接口:
AutoCloseable
,BaseStream<Long,
LongStream>
Stream
的 long
原始特化。
以下示例说明了使用 Stream
和 LongStream
的聚合操作,计算红色小部件的权重之和:
long sum = widgets.stream()
.filter(w -> w.getColor() == RED)
.mapToLong(w -> w.getWeight())
.sum();
有关流、流操作、流管道和并行性的其他规范,请参阅 Stream
的类文档和 java.util.stream 的包文档。
- 自从:
- 1.8
- 参见:
-
内部类总结
修饰符和类型接口描述static interface
LongStream
的可变构建器。static interface
表示接受long
值参数和 LongConsumer 且不返回任何结果的操作。 -
方法总结
修饰符和类型方法描述boolean
allMatch
(LongPredicate predicate) 返回此流的所有元素是否与提供的谓词匹配。boolean
anyMatch
(LongPredicate predicate) 返回此流的任何元素是否与提供的谓词匹配。返回由该流的元素组成的DoubleStream
,转换为double
。average()
返回一个OptionalDouble
描述该流元素的算术平均值,或者如果该流为空则返回一个空的可选值。boxed()
返回一个Stream
由该流的元素组成,每个元素装箱到一个Long
。static LongStream.Builder
builder()
返回LongStream
的构建器。<R> R
collect
(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) 对此流的元素执行 可变减少 操作。static LongStream
concat
(LongStream a, LongStream b) 创建一个惰性串联流,其元素是第一个流的所有元素,后跟第二个流的所有元素。long
count()
返回此流中元素的计数。distinct()
返回由该流的不同元素组成的流。default LongStream
dropWhile
(LongPredicate predicate) 如果此流是有序的,则返回一个流,该流由删除与给定谓词匹配的元素的最长前缀后的此流的剩余元素组成。static LongStream
empty()
返回一个空的顺序LongStream
。filter
(LongPredicate predicate) 返回一个流,该流由与给定谓词匹配的此流的元素组成。findAny()
返回描述流中某些元素的OptionalLong
,如果流为空,则返回空的OptionalLong
。返回描述此流的第一个元素的OptionalLong
,如果流为空,则返回空的OptionalLong
。flatMap
(LongFunction<? extends LongStream> mapper) 返回一个流,该流由将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容组成的结果。void
forEach
(LongConsumer action) 对此流的每个元素执行一个操作。void
forEachOrdered
(LongConsumer action) 对此流的每个元素执行一个操作,保证每个元素都按照流的遇到顺序处理,这些流具有定义的遇到顺序。static LongStream
返回无限顺序无序流,其中每个元素都由提供的LongSupplier
生成。static LongStream
iterate
(long seed, LongPredicate hasNext, LongUnaryOperator next) 返回由给定的next
函数迭代应用到初始元素而产生的顺序有序的LongStream
,条件是满足给定的hasNext
谓词。static LongStream
iterate
(long seed, LongUnaryOperator f) 返回由函数f
迭代应用到初始元素seed
产生的无限顺序有序LongStream
,产生由seed
、f(seed)
、f(f(seed))
等组成的Stream
。limit
(long maxSize) 返回由该流的元素组成的流,截断后的长度不超过maxSize
。map
(LongUnaryOperator mapper) 返回一个流,该流由将给定函数应用于此流的元素的结果组成。default LongStream
返回一个流,该流由用多个元素(特别是零个或多个元素)替换此流的每个元素的结果组成。mapToDouble
(LongToDoubleFunction mapper) 返回一个DoubleStream
,由将给定函数应用于此流的元素的结果组成。mapToInt
(LongToIntFunction mapper) 返回一个IntStream
,由将给定函数应用于此流的元素的结果组成。<U> Stream<U>
mapToObj
(LongFunction<? extends U> mapper) 返回一个对象值Stream
,由将给定函数应用于此流的元素的结果组成。max()
返回一个OptionalLong
描述这个流的最大元素,或者如果这个流是空的则返回一个空的可选值。min()
返回一个OptionalLong
描述这个流的最小元素,或者如果这个流是空的则返回一个空的可选值。boolean
noneMatch
(LongPredicate predicate) 返回此流中是否没有元素与提供的谓词匹配。static LongStream
of
(long t) 返回包含单个元素的顺序LongStream
。static LongStream
of
(long... values) 返回其元素为指定值的顺序有序流。peek
(LongConsumer action) 返回一个由该流的元素组成的流,当从结果流中消耗元素时,还会对每个元素执行提供的操作。static LongStream
range
(long startInclusive, long endExclusive) 通过1
的增量步返回从startInclusive
(含)到endExclusive
(不含)的顺序有序LongStream
。static LongStream
rangeClosed
(long startInclusive, long endInclusive) 通过1
的增量步返回从startInclusive
(含)到endInclusive
(含)的顺序有序LongStream
。long
reduce
(long identity, LongBinaryOperator op) skip
(long n) 在丢弃流的前n
个元素后,返回由该流的剩余元素组成的流。sorted()
返回一个流,该流由按排序顺序排列的此流的元素组成。long
sum()
返回此流中元素的总和。返回一个LongSummaryStatistics
描述有关此流元素的各种摘要数据。default LongStream
takeWhile
(LongPredicate predicate) 如果此流是有序的,则返回一个流,该流由从此流中获取的与给定谓词匹配的元素的最长前缀组成。long[]
toArray()
返回包含此流的元素的数组。在接口 java.util.stream.BaseStream 中声明的方法
close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered
-
方法详情
-
filter
返回一个流,该流由与给定谓词匹配的此流的元素组成。这是一个 中间操作 。
-
map
返回一个流,该流由将给定函数应用于此流的元素的结果组成。这是一个 中间操作 。
-
mapToObj
返回一个对象值Stream
,由将给定函数应用于此流的元素的结果组成。这是一个 中间操作 。
-
mapToInt
返回一个IntStream
,由将给定函数应用于此流的元素的结果组成。这是一个 中间操作 。
-
mapToDouble
返回一个DoubleStream
,由将给定函数应用于此流的元素的结果组成。这是一个 中间操作 。
-
flatMap
返回一个流,该流由将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容组成的结果。每个映射流在其内容被放入该流后都是closed
。 (如果map流是null
,则使用空流。)这是一个 中间操作 。
-
mapMulti
返回一个流,该流由用多个元素(特别是零个或多个元素)替换此流的每个元素的结果组成。通过将提供的映射函数与接受替换元素的consumer参数一起应用于每个元素来执行替换。映射函数零次或多次调用消费者以提供替换元素。这是一个 中间操作 。
如果 consumer 参数在其映射函数的应用范围之外使用,则结果未定义。
-
distinct
LongStream distinct()返回由该流的不同元素组成的流。这是一个 有状态的中间操作 。
- 返回:
- 新流
-
sorted
LongStream sorted()返回一个流,该流由按排序顺序排列的此流的元素组成。这是一个 有状态的中间操作 。
- 返回:
- 新流
-
peek
返回一个由该流的元素组成的流,当从结果流中消耗元素时,还会对每个元素执行提供的操作。这是一个 中间操作 。
对于并行流管道,可以在上游操作使元素可用的任何时间和任何线程中调用操作。如果操作修改共享状态,则它负责提供所需的同步。
- API 注意:
-
此方法的存在主要是为了支持调试,您希望在元素流过管道中的某个点时查看元素:
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();
在流实现能够优化部分或所有元素的生产的情况下(例如使用像
findFirst
这样的短路操作,或者在count()
中描述的示例中),将不会为这些元素调用操作。 - 参数:
action
- 一个 不干扰 在元素从流中消耗时执行的操作- 返回:
- 新流
-
limit
返回由该流的元素组成的流,截断后的长度不超过maxSize
。这是一个 短路状态中间操作 。
- API 注意:
-
虽然
limit()
通常是顺序流管道上的廉价操作,但它在有序并行管道上可能非常昂贵,尤其是对于maxSize
的大值,因为limit(n)
不仅限于返回任何 n 元素,而且返回遇到顺序中的 first n 元素。如果您的情况的语义允许,使用无序流源(例如generate(LongSupplier)
)或使用BaseStream.unordered()
删除排序约束可能会导致并行管道中的limit()
显着加速。如果需要与遇到顺序保持一致,并且在并行管道中使用limit()
时性能或内存利用率不佳,则切换到使用BaseStream.sequential()
的顺序执行可能会提高性能。 - 参数:
maxSize
- 流应限制为的元素数- 返回:
- 新流
- 抛出:
IllegalArgumentException
- 如果maxSize
为负
-
skip
- API 注意:
-
虽然
skip()
通常是顺序流管道上的廉价操作,但它在有序并行管道上可能非常昂贵,尤其是对于较大的n
值,因为skip(n)
不仅要跳过任何 n 元素,还要跳过遇到顺序中的 first n 元素。如果您的情况的语义允许,使用无序流源(例如generate(LongSupplier)
)或使用BaseStream.unordered()
删除排序约束可能会导致并行管道中的skip()
显着加速。如果需要与遇到顺序保持一致,并且在并行管道中使用skip()
时性能或内存利用率不佳,则切换到使用BaseStream.sequential()
的顺序执行可能会提高性能。 - 参数:
n
- 要跳过的前导元素数- 返回:
- 新流
- 抛出:
IllegalArgumentException
- 如果n
为负
-
takeWhile
如果此流是有序的,则返回一个流,该流由从此流中获取的与给定谓词匹配的元素的最长前缀组成。否则,如果此流是无序的,则返回一个流,该流由从此流中获取的与给定谓词匹配的元素的子集组成。如果此流是有序的,则最长前缀是此流中与给定谓词匹配的元素的连续序列。序列的第一个元素是该流的第一个元素,紧跟在序列最后一个元素之后的元素不匹配给定的谓词。
如果这个流是无序的,并且这个流的一些(但不是全部)元素匹配给定的谓词,那么这个操作的行为是不确定的;可以自由获取匹配元素的任何子集(包括空集)。
独立于此流是有序的还是无序的如果此流的所有元素都匹配给定的谓词,则此操作获取所有元素(结果与输入相同),或者如果流中没有元素匹配给定的谓词则没有元素被采用(结果是一个空流)。
这是一个 短路状态中间操作 。
- API 注意:
-
虽然
takeWhile()
通常是顺序流管道上的廉价操作,但它在有序并行管道上可能非常昂贵,因为该操作被限制为不仅返回任何有效前缀,而且返回遇到顺序中元素的最长前缀。如果您的情况的语义允许,使用无序流源(例如generate(LongSupplier)
)或使用BaseStream.unordered()
删除排序约束可能会导致并行管道中的takeWhile()
显着加速。如果需要与遇到顺序保持一致,并且在并行管道中使用takeWhile()
时性能或内存利用率不佳,则切换到使用BaseStream.sequential()
的顺序执行可能会提高性能。 - 实现要求:
-
默认实现获取此流的
spliterator
,包装该拆分器以支持此遍历操作的语义,并返回与包装的拆分器关联的新流。返回的流保留了该流的执行特征(即根据BaseStream.isParallel()
并行或顺序执行),但包装的拆分器可能会选择不支持拆分。当返回的流关闭时,将调用返回流和此流的关闭处理程序。 - 参数:
predicate
- 一个 不干扰 , 无国籍的 谓词应用于元素以确定元素的最长前缀。- 返回:
- 新流
- 自从:
- 9
-
dropWhile
如果此流是有序的,则返回一个流,该流由删除与给定谓词匹配的元素的最长前缀后的此流的剩余元素组成。否则,如果此流是无序的,则在删除与给定谓词匹配的元素子集后,返回由此流的剩余元素组成的流。如果此流是有序的,则最长前缀是此流中与给定谓词匹配的元素的连续序列。序列的第一个元素是该流的第一个元素,紧跟在序列最后一个元素之后的元素不匹配给定的谓词。
如果这个流是无序的,并且这个流的一些(但不是全部)元素匹配给定的谓词,那么这个操作的行为是不确定的;可以随意删除匹配元素的任何子集(包括空集)。
独立于此流是有序的还是无序的如果此流的所有元素都匹配给定的谓词,则此操作删除所有元素(结果是一个空流),或者如果流中没有元素匹配给定的谓词则不删除任何元素(结果与输入相同)。
这是一个 有状态的中间操作 。
- API 注意:
-
虽然
dropWhile()
通常是顺序流管道上的廉价操作,但它在有序并行管道上可能非常昂贵,因为操作被限制为不仅返回任何有效前缀,而且返回遇到顺序中元素的最长前缀。如果您的情况的语义允许,使用无序流源(例如generate(LongSupplier)
)或使用BaseStream.unordered()
删除排序约束可能会导致并行管道中的dropWhile()
显着加速。如果需要与遇到顺序保持一致,并且在并行管道中使用dropWhile()
时性能或内存利用率不佳,则切换到使用BaseStream.sequential()
的顺序执行可能会提高性能。 - 实现要求:
-
默认实现获取此流的
spliterator
,包装该拆分器以支持此遍历操作的语义,并返回与包装的拆分器关联的新流。返回的流保留了该流的执行特征(即根据BaseStream.isParallel()
并行或顺序执行),但包装的拆分器可能会选择不支持拆分。当返回的流关闭时,将调用返回流和此流的关闭处理程序。 - 参数:
predicate
- 一个 不干扰 , 无国籍的 谓词应用于元素以确定元素的最长前缀。- 返回:
- 新流
- 自从:
- 9
-
forEach
对此流的每个元素执行一个操作。这是一个 终端操作 。
对于并行流管道,此操作确实not保证尊重流的遇到顺序,因为这样做会牺牲并行性的好处。对于任何给定的元素,该操作可以在库选择的任何时间和任何线程中执行。如果操作访问共享状态,它负责提供所需的同步。
- 参数:
action
- 对元素执行的 不干扰 操作
-
forEachOrdered
对此流的每个元素执行一个操作,保证每个元素都按照流的遇到顺序处理,这些流具有定义的遇到顺序。这是一个 终端操作 。
- 参数:
action
- 对元素执行的 不干扰 操作- 参见:
-
toArray
long[] toArray()返回包含此流的元素的数组。这是一个 终端操作 。
- 返回:
- 包含此流的元素的数组
-
reduce
使用提供的标识值和 联想的 累加函数对此流的元素执行 减少,并返回减少的值。这等同于:
但不限于按顺序执行。long result = identity; for (long element : this stream) result = accumulator.applyAsLong(result, element) return result;
identity
值必须是累加器函数的标识。这意味着对于所有x
,accumulator.apply(identity, x)
等于x
。accumulator
函数必须是 联想的 函数。这是一个 终端操作 。
-
reduce
使用 联想的 累加函数对此流的元素执行 减少,并返回描述减少值的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
函数必须是 联想的 函数。这是一个 终端操作 。
-
collect
对此流的元素执行 可变减少 操作。可变缩减是这样一种缩减,其中缩减值是可变结果容器,例如ArrayList
,并且通过更新结果状态而不是替换结果来合并元素。这产生的结果等同于:R result = supplier.get(); for (long element : this stream) accumulator.accept(result, element); return result;
与
reduce(long, LongBinaryOperator)
一样,collect
操作可以并行化而不需要额外的同步。这是一个 终端操作 。
-
sum
long sum()- 返回:
- 此流中元素的总和
-
min
OptionalLong min()返回一个OptionalLong
描述这个流的最小元素,或者如果这个流是空的则返回一个空的可选值。这是 减少 的特例,相当于:return reduce(Long::min);
这是一个 终端操作 。
- 返回:
-
包含此流的最小元素的
OptionalLong
,如果流为空,则为空的OptionalLong
-
max
OptionalLong max()返回一个OptionalLong
描述这个流的最大元素,或者如果这个流是空的则返回一个空的可选值。这是 减少 的特例,相当于:return reduce(Long::max);
这是一个 终端操作 。
- 返回:
-
包含此流的最大元素的
OptionalLong
,如果流为空,则为空的OptionalLong
-
count
long count()- API 注意:
-
如果实现能够直接从流源计算计数,则它可以选择不执行流管道(顺序或并行)。在这种情况下,不会遍历任何源元素,也不会评估任何中间操作。具有副作用的行为参数可能会受到影响,除了调试等无害情况外,强烈建议不要这样做。例如,考虑以下流:
流源覆盖的元素数量是已知的,中间操作LongStream s = LongStream.of(1, 2, 3, 4); long count = s.peek(System.out::println).count();
peek
不会从流中注入或删除元素(对于flatMap
或filter
操作可能就是这种情况)。因此计数为 4 并且不需要执行管道,作为副作用,打印出元素。 - 返回:
- 此流中的元素数
-
average
OptionalDouble average()- 返回:
-
包含此流的平均元素的
OptionalDouble
,如果流为空,则为空可选
-
summaryStatistics
LongSummaryStatistics summaryStatistics()- 返回:
-
a
LongSummaryStatistics
描述有关此流元素的各种摘要数据
-
anyMatch
返回此流的任何元素是否与提供的谓词匹配。如果不需要确定结果,则可以不对所有元素评估谓词。如果流为空,则返回false
并且不评估谓词。这是一个 短路端子操作 。
-
allMatch
返回此流的所有元素是否与提供的谓词匹配。如果不需要确定结果,则可以不对所有元素评估谓词。如果流为空,则返回true
并且不评估谓词。这是一个 短路端子操作 。
-
noneMatch
返回此流中是否没有元素与提供的谓词匹配。如果不需要确定结果,则可以不对所有元素评估谓词。如果流为空,则返回true
并且不评估谓词。这是一个 短路端子操作 。
-
findFirst
OptionalLong findFirst()- 返回:
-
一个
OptionalLong
描述这个流的第一个元素,或者一个空的OptionalLong
如果流是空的
-
findAny
OptionalLong findAny()返回描述流中某些元素的OptionalLong
,如果流为空,则返回空的OptionalLong
。这是一个 短路端子操作 。
此操作的行为显然是不确定的;可以自由选择流中的任何元素。这是为了在并行操作中实现最大性能;代价是对同一源的多次调用可能不会返回相同的结果。 (如果需要稳定的结果,请改用
findFirst()
。)- 返回:
-
一个
OptionalLong
描述这个流的一些元素,或者一个空的OptionalLong
如果流是空的 - 参见:
-
asDoubleStream
DoubleStream asDoubleStream()- 返回:
-
一个
DoubleStream
由这个流的元素组成,转换为double
-
boxed
- 返回:
-
a
Stream
与此流的元素一致,每个装箱到Long
-
builder
返回LongStream
的构建器。- 返回:
- 流生成器
-
empty
返回一个空的顺序LongStream
。- 返回:
- 一个空的顺序流
-
of
返回包含单个元素的顺序LongStream
。- 参数:
t
- 单个元素- 返回:
- 单例顺序流
-
of
返回其元素为指定值的顺序有序流。- 参数:
values
- 新流的元素- 返回:
- 新流
-
iterate
返回由函数f
迭代应用到初始元素seed
产生的无限顺序有序LongStream
,产生由seed
、f(seed)
、f(f(seed))
等组成的Stream
。LongStream
中的第一个元素(位置0
)将是提供的seed
。对于n > 0
,位置n
的元素将是将函数f
应用于位置n - 1
的元素的结果。对一个元素应用
f
的动作 发生之前 对后续元素应用f
的动作。对于任何给定的元素,操作可以在库选择的任何线程中执行。- 参数:
seed
- 初始元素f
- 应用于前一个元素以生成新元素的函数- 返回:
-
一个新的顺序
LongStream
-
iterate
返回由给定的next
函数迭代应用到初始元素而产生的顺序有序的LongStream
,条件是满足给定的hasNext
谓词。一旦hasNext
谓词返回 false,流就会终止。LongStream.iterate
应该产生与相应的 for 循环产生的相同的元素序列:for (long index=seed; hasNext.test(index); index = next.applyAsLong(index)) { ... }
如果
hasNext
谓词不保留种子值,则生成的序列可能为空。否则,第一个元素将是提供的seed
值,下一个元素(如果存在)将是将next
函数应用于seed
值的结果,依此类推,直到hasNext
谓词指示流应该终止。将
hasNext
谓词应用于元素的操作 发生之前 将next
函数应用于该元素的操作。对一个元素应用next
函数的动作发生之前对后续元素应用hasNext
谓词的操作。对于任何给定的元素,可以在库选择的任何线程中执行操作。- 参数:
seed
- 初始元素hasNext
- 应用于元素以确定流何时必须终止的谓词。next
- 应用于前一个元素以生成新元素的函数- 返回:
-
一个新的顺序
LongStream
- 自从:
- 9
-
generate
返回无限顺序无序流,其中每个元素都由提供的LongSupplier
生成。这适用于生成恒定流、随机元素流等。- 参数:
s
- 生成元素的LongSupplier
- 返回:
-
一个新的无限顺序无序
LongStream
-
range
通过1
的增量步返回从startInclusive
(含)到endExclusive
(不含)的顺序有序LongStream
。- API 注意:
-
可以使用
for
循环按如下方式依次生成递增值的等效序列:for (long i = startInclusive; i < endExclusive ; i++) { ... }
- 参数:
startInclusive
-(含)初始值endExclusive
- 独家上限- 返回:
long
元素范围的顺序LongStream
-
rangeClosed
通过1
的增量步返回从startInclusive
(含)到endInclusive
(含)的顺序有序LongStream
。- API 注意:
-
可以使用
for
循环按如下方式依次生成递增值的等效序列:for (long i = startInclusive; i <= endInclusive ; i++) { ... }
- 参数:
startInclusive
-(含)初始值endInclusive
- 包含上限- 返回:
long
元素范围的顺序LongStream
-
concat
创建一个惰性串联流,其元素是第一个流的所有元素,后跟第二个流的所有元素。如果两个输入流都是有序的,则结果流是有序的,如果其中一个输入流是并行的,则结果流是并行的。当结果流关闭时,将调用两个输入流的关闭处理程序。此方法对两个输入流进行操作并将每个流绑定到其源。因此,对输入流源的后续修改可能不会反映在级联流结果中。
- API 注意:
-
为了保留优化机会,此方法将每个流绑定到其源并仅接受两个流作为参数。例如,如果知道每个输入流源的确切大小,则可以计算连接流源的确切大小。要在不绑定或不嵌套调用此方法的情况下连接更多流,请尝试使用身份函数创建流流和平面映射流,例如:
LongStream concat = Stream.of(s1, s2, s3, s4).flatMapToLong(s -> s);
- 实现注意事项:
-
从重复串联构造流时要小心。访问深度串联流的元素可能会导致深度调用链,甚至
StackOverflowError
。 - 参数:
a
- 第一个流b
- 第二个流- 返回:
- 两个输入流的连接
-