public class Steam<T> extends Object implements Stream<T>, Iterable<T>, CollectableStream<T>
它分为串行流和并行流
并行流会使用拆分器Spliterator将操作拆分为多个异步任务ForkJoinTask执行
这些异步任务默认使用ForkJoinPool线程池进行管理
Stream| 限定符和类型 | 类和说明 |
|---|---|
static interface |
Steam.Builder<T> |
| 限定符和类型 | 字段和说明 |
|---|---|
protected static int |
NOT_FOUND_INDEX
代表不存在的下标, 一般用于并行流的下标, 或者未找到元素时的下标
|
protected Stream<T> |
stream
原始的流实例
|
| 限定符和类型 | 方法和说明 |
|---|---|
boolean |
allMatch(Predicate<? super T> predicate)
判断是否所有元素满足给定断言
|
boolean |
anyMatch(Predicate<? super T> predicate)
判断是否有任何一个元素满足给定断言
|
Optional<T> |
at(Integer idx)
获取流中指定下标的元素,如果是负数,则从最后一个开始数起
|
static <T> Steam.Builder<T> |
builder()
返回
Steam的建造器 |
void |
close()
关闭流
|
<R,A> R |
collect(Collector<? super T,A,R> collector)
对元素进行收集,并返回收集后的元素
这是一个终端操作
|
<R> R |
collect(Supplier<R> supplier,
BiConsumer<R,? super T> accumulator,
BiConsumer<R,R> combiner)
对元素进行收集,并返回收集后的容器
这是一个终端操作
|
static <T> Steam<T> |
concat(Iterable<? extends T> a,
Iterable<? extends T> b)
创建一个惰性拼接流,其元素是第一个流的所有元素,然后是第二个流的所有元素。
|
static <T> Steam<T> |
concat(Stream<? extends T> a,
Stream<? extends T> b)
创建一个惰性拼接流,其元素是第一个流的所有元素,然后是第二个流的所有元素。
|
long |
count()
返回流元素个数
|
I |
distinct()
返回一个具有去重特征的流 非并行流(顺序流)下对于重复元素,保留遇到顺序中最先出现的元素,并行流情况下不能保证具体保留哪一个
这是一个有状态中间操作
|
<F> Steam<T> |
distinct(Function<? super T,F> keyExtractor)
返回一个具有去重特征的流 非并行流(顺序流)下对于重复元素,保留遇到顺序中最先出现的元素,并行流情况下不能保证具体保留哪一个
这是一个有状态中间操作
|
static <T> Steam<T> |
empty()
返回空的串行流
|
boolean |
equals(Object obj)
equals
|
<R> Steam<T> |
filter(Function<? super T,? extends R> mapper,
R value)
过滤元素,返回与 指定操作结果 匹配 指定值 的元素组成的流
这是一个无状态中间操作
|
I |
filter(Predicate<? super T> predicate)
过滤元素,返回与指定断言匹配的元素组成的流
这是一个无状态中间操作
|
<R> Steam<T> |
filterContains(Function<? super T,? extends R> mapper,
Iterable<T> others)
过滤同类型集合中某一操作相同值的数据
filter(Function, Object) |
Steam<T> |
filterIdx(BiPredicate<? super T,Integer> predicate)
过滤元素,返回与指定断言匹配的元素组成的流,断言带下标
|
Optional<T> |
findAny()
考虑性能,随便取一个,这里不是随机取一个,是随便取一个
|
Optional<T> |
findFirst()
获取第一个元素
|
Optional<T> |
findFirst(Predicate<? super T> predicate)
获取与给定断言匹配的第一个元素
|
Integer |
findFirstIdx(Predicate<? super T> predicate)
获取与给定断言匹配的第一个元素的下标,并行流下标永远为-1
|
Optional<T> |
findLast()
获取最后一个元素
|
Optional<T> |
findLast(Predicate<? super T> predicate)
获取与给定断言匹配的最后一个元素
|
Integer |
findLastIdx(Predicate<? super T> predicate)
获取与给定断言匹配的最后一个元素的下标,并行流下标永远为-1
|
<R> Steam<R> |
flat(Function<? super T,? extends Iterable<? extends R>> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流
这是一个无状态中间操作
例如,将users里所有user的id和parentId组合在一起,形成一个新的流:
Steam<Long> ids = Steam.of(users).flatMap(user -> Steam.of(user.getId(), user.getParentId()));
|
<R> Steam<R> |
flatIdx(BiFunction<? super T,Integer,? extends Iterable<? extends R>> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流,操作带下标,并行流时下标永远为-1
这是一个无状态中间操作
|
<R> Steam<R> |
flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流
这是一个无状态中间操作
例如,将users里所有user的id和parentId组合在一起,形成一个新的流:
Steam<Long> ids = Steam.of(users).flatMap(user -> Steam.of(user.getId(), user.getParentId()));
|
DoubleStream |
flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流
这是一个无状态中间操作
|
IntStream |
flatMapToInt(Function<? super T,? extends IntStream> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流
这是一个无状态中间操作
|
LongStream |
flatMapToLong(Function<? super T,? extends LongStream> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流
这是一个无状态中间操作
|
void |
forEach(Consumer<? super T> action)
对流里面的每一个元素执行一个操作
这是一个终端操作
|
void |
forEachIdx(BiConsumer<? super T,Integer> action)
对流里面的每一个元素执行一个操作,操作带下标,并行流时下标永远为-1
这是一个终端操作
|
void |
forEachOrdered(Consumer<? super T> action)
对流里面的每一个元素按照顺序执行一个操作
这是一个终端操作
|
void |
forEachOrderedIdx(BiConsumer<? super T,Integer> action)
对流里面的每一个元素按照顺序执行一个操作,操作带下标,并行流时下标永远为-1
这是一个终端操作
|
static <T> Steam<T> |
generate(Supplier<T> s)
返回无限串行无序流
其中每一个元素都由给定的
Supplier生成
适用场景在一些生成常量流、随机元素等 |
int |
hashCode()
hashcode
|
boolean |
isParallel()
返回流的并行状态
|
static <T> Steam<T> |
iterate(T seed,
Predicate<? super T> hasNext,
UnaryOperator<T> next)
返回无限有序流
该流由 初始值 然后判断条件 以及执行 迭代函数 进行迭代获取到元素
例如
Steam.iterate(0, i -> i < 3, i -> ++i)
就可以创建包含元素0,1,2的流,使用AbstractStreamWrapper.limit(long)可以限制元素个数
|
static <T> Steam<T> |
iterate(T seed,
UnaryOperator<T> f)
返回无限有序流
该流由 初始值 以及执行 迭代函数 进行迭代获取到元素
例如
Steam.iterate(0, i -> i + 1)
就可以创建从0开始,每次+1的无限流,使用AbstractStreamWrapper.limit(long)可以限制元素个数
|
Iterator<T> |
iterator()
返回流的迭代器
|
I |
limit(long maxSize)
返回截取后面一些元素的流
这是一个短路状态中间操作
|
Steam<T> |
log()
返回叠加调用
PrintStream.println(Object)打印出结果的流 |
<R> Steam<R> |
map(Function<? super T,? extends R> mapper)
返回与指定函数将元素作为参数执行的结果组成的流
这是一个无状态中间操作
|
<R> Steam<R> |
mapIdx(BiFunction<? super T,Integer,? extends R> mapper)
返回与指定函数将元素作为参数执行的结果组成的流,操作带下标
|
<R> Steam<R> |
mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流,操作带一个方法,调用该方法可增加元素
这是一个无状态中间操作
|
DoubleStream |
mapToDouble(ToDoubleFunction<? super T> mapper)
和
Stream.map(Function)一样,只不过函数的返回值必须为double类型
这是一个无状态中间操作 |
IntStream |
mapToInt(ToIntFunction<? super T> mapper)
和
Stream.map(Function)一样,只不过函数的返回值必须为int类型
这是一个无状态中间操作 |
LongStream |
mapToLong(ToLongFunction<? super T> mapper)
和
Stream.map(Function)一样,只不过函数的返回值必须为long类型
这是一个无状态中间操作 |
Optional<T> |
max(Comparator<? super T> comparator)
获取最大值
|
Optional<T> |
min(Comparator<? super T> comparator)
获取最小值
|
boolean |
noneMatch(Predicate<? super T> predicate)
判断是否没有元素满足给定断言
|
Steam<T> |
nonNull()
过滤掉空元素
|
static <T> Steam<T> |
of(Iterable<T> iterable)
通过实现了
Iterable接口的对象创建串行流 |
static <T> Steam<T> |
of(Iterable<T> iterable,
boolean parallel)
通过传入的
Iterable创建流 |
static <T> Steam<T> |
of(Stream<T> stream)
通过传入的
Stream创建流 |
static <T> Steam<T> |
of(T... values)
返回包含指定元素的串行流
|
static <T> Steam<T> |
of(T t)
返回包含单个元素的串行流
|
I |
onClose(Runnable closeHandler)
在流关闭时执行操作
|
I |
parallel()
将流转换为并行
|
Steam<T> |
parallel(boolean parallel)
更改流的并行状态
|
I |
peek(Consumer<? super T> action)
返回与指定函数将元素作为参数执行后组成的流。
|
Steam<T> |
peekIdx(SerBiCons<? super T,Integer> action)
peekIdx.
|
Steam<T> |
push(T... obj)
与给定元素组成的流合并,成为新的流
|
Steam<T> |
push(T obj)
与给定元素组成的流合并,成为新的流
|
Optional<T> |
reduce(BinaryOperator<T> accumulator)
对元素进行聚合,并返回聚合后用
Optional包裹的值,相当于在for循环里写sum=sum+ints[i]
该操作相当于:
{@code
boolean foundAny = false;
T result = null;
for (T element : this stream) {
if (! |
T |
reduce(T identity,
BinaryOperator<T> accumulator)
对元素进行聚合,并返回聚合后的值,相当于在for循环里写sum=sum+ints[i]
这是一个终端操作
求和、最小值、最大值、平均值和转换成一个String字符串均为聚合操作 例如这里对int进行求和可以写成:
Integer sum = integers.reduce(0, (a, b) -> a+b);
或者写成:
Integer sum = integers.reduce(0, Integer::sum);
|
<U> U |
reduce(U identity,
BiFunction<U,? super T,U> accumulator,
BinaryOperator<U> combiner)
对元素进行聚合,并返回聚合后的值,并行流时聚合拿到的初始值不稳定
这是一个终端操作
|
Steam<T> |
reverseSorted(Comparator<T> comparator)
反转顺序
|
I |
sequential()
返回一个串行流,该方法可以将并行流转换为串行流
|
I |
skip(long n)
返回丢弃前面n个元素后的剩余元素组成的流,如果当前元素个数小于n,则返回一个元素为空的流
这是一个有状态中间操作
|
I |
sorted()
返回一个元素按自然顺序排序的流
如果此流的元素不是
Comparable ,则在执行终端操作时可能会抛出 java.lang.ClassCastException
对于顺序流,排序是稳定的。 |
I |
sorted(Comparator<? super T> comparator)
返回一个元素按指定的
Comparator排序的流
如果此流的元素不是Comparable ,则在执行终端操作时可能会抛出java.lang.ClassCastException
对于顺序流,排序是稳定的。 |
Steam<T> |
splice(int start,
int deleteCount,
T... items)
类似js的splice函数
|
Steam<Steam<T>> |
split(int batchSize)
按指定长度切分为双层流
形如:[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
|
static <T extends CharSequence> |
split(T str,
String regex)
拆分字符串,转换为串行流
|
Spliterator<T> |
spliterator()
返回流的拆分器
|
Steam<List<T>> |
splitList(int batchSize)
按指定长度切分为元素为list的流
形如:[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
|
Object[] |
toArray()
返回一个包含此流元素的数组
这是一个终端操作
|
<A> A[] |
toArray(IntFunction<A[]> generator)
返回一个包含此流元素的指定的数组,例如以下代码编译正常,但运行时会抛出
ArrayStoreException
{@code String[] strings = Stream. |
String |
toString()
toString
|
I |
unordered()
返回一个无序流(无手动排序)
标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能
|
Steam<T> |
unshift(T... obj)
给定元素组成的流与当前流合并,成为新的流
|
Steam<T> |
unshift(T obj)
给定元素组成的流与当前流合并,成为新的流
|
protected Steam<T> |
wrap(Stream<T> stream)
构建一个
Steam实例 |
<U,R> Steam<R> |
zip(Iterable<U> other,
BiFunction<? super T,? super U,? extends R> zipper)
将 现有元素 与 给定迭代器中对应位置的元素 使用 zipper 转换为新的元素,并返回新元素组成的流
新流的数量等于旧流元素的数量 使用 zipper 转换时, 如果对应位置上已经没有other元素,则other元素为null |
forEach, iterator, spliteratorgroup, group, group, join, join, join, partition, partition, partition, toCollection, toIdxMap, toIdxMap, toList, toMap, toMap, toMap, toMap, toSet, toUnmodifiableList, toUnmodifiableMap, toUnmodifiableMap, toUnmodifiableSet, toZipallMatch, anyMatch, collect, collect, count, distinct, filter, findAny, findFirst, flatMapToDouble, flatMapToInt, flatMapToLong, forEach, forEachOrdered, limit, mapToDouble, mapToInt, mapToLong, max, min, noneMatch, peek, reduce, reduce, reduce, skip, sorted, sorted, toArray, toArrayclose, isParallel, iterator, onClose, parallel, sequential, spliterator, unorderedprotected static final int NOT_FOUND_INDEX
protected Stream<T> stream
public static <T> Steam.Builder<T> builder()
Steam的建造器public static <T> Steam<T> empty()
public static <T> Steam<T> of(T t)
@SafeVarargs public static <T> Steam<T> of(T... values)
public static <T> Steam<T> iterate(T seed, UnaryOperator<T> f)
返回无限有序流 该流由 初始值 以及执行 迭代函数 进行迭代获取到元素
例如
Steam.iterate(0, i -> i + 1)
就可以创建从0开始,每次+1的无限流,使用AbstractStreamWrapper.limit(long)可以限制元素个数
public static <T> Steam<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)
例如
Steam.iterate(0, i -> i < 3, i -> ++i)
就可以创建包含元素0,1,2的流,使用AbstractStreamWrapper.limit(long)可以限制元素个数
T - 元素类型seed - 初始值hasNext - 条件值next - 用上一个元素作为参数执行并返回一个新的元素public static <T> Steam<T> generate(Supplier<T> s)
返回无限串行无序流
其中每一个元素都由给定的Supplier生成
适用场景在一些生成常量流、随机元素等
public static <T> Steam<T> concat(Stream<? extends T> a, Stream<? extends T> b)
创建一个惰性拼接流,其元素是第一个流的所有元素,然后是第二个流的所有元素。 如果两个输入流都是有序的,则结果流是有序的,如果任一输入流是并行的,则结果流是并行的。 当结果流关闭时,两个输入流的关闭处理程序都会被调用。
从重复串行流进行拼接时可能会导致深度调用链甚至抛出 StackOverflowException
public static <T> Steam<T> concat(Iterable<? extends T> a, Iterable<? extends T> b)
创建一个惰性拼接流,其元素是第一个流的所有元素,然后是第二个流的所有元素。 如果两个输入流都是有序的,则结果流是有序的,如果任一输入流是并行的,则结果流是并行的。 当结果流关闭时,两个输入流的关闭处理程序都会被调用。
从重复串行流进行拼接时可能会导致深度调用链甚至抛出 StackOverflowException
T - 元素类型a - 第一个流b - 第二个流public static <T> Steam<T> of(Iterable<T> iterable, boolean parallel)
Iterable创建流T - 元素类型iterable - Iterableparallel - 是否并行public static <T extends CharSequence> Steam<String> split(T str, String regex)
T - a T classstr - 字符串regex - 正则public <R> Steam<T> filter(Function<? super T,? extends R> mapper, R value)
R - 返回类型mapper - 操作value - 用来匹配的值public Steam<T> filterIdx(BiPredicate<? super T,Integer> predicate)
predicate - 断言public <R> Steam<R> map(Function<? super T,? extends R> mapper)
返回与指定函数将元素作为参数执行的结果组成的流 这是一个无状态中间操作
public <R> Steam<R> mapIdx(BiFunction<? super T,Integer,? extends R> mapper)
R - 函数执行后返回的类型mapper - 指定的函数public <R> Steam<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流 这是一个无状态中间操作 例如,将users里所有user的id和parentId组合在一起,形成一个新的流:
Steam<Long> ids = Steam.of(users).flatMap(user -> Steam.of(user.getId(), user.getParentId()));
public <R> Steam<R> flatIdx(BiFunction<? super T,Integer,? extends Iterable<? extends R>> mapper)
R - 拆分后流的元素类型mapper - 操作,返回流public <R> Steam<R> flat(Function<? super T,? extends Iterable<? extends R>> mapper)
Steam<Long> ids = Steam.of(users).flatMap(user -> Steam.of(user.getId(), user.getParentId()));
R - 拆分后流的元素类型mapper - 操作,返回可迭代对象public <R> Steam<R> mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)
R - 拆分后流的元素类型mapper - 操作,返回流public <F> Steam<T> distinct(Function<? super T,F> keyExtractor)
F - a F classkeyExtractor - 去重依据public Steam<T> log()
PrintStream.println(Object)打印出结果的流public void forEachIdx(BiConsumer<? super T,Integer> action)
action - 操作public void forEachOrderedIdx(BiConsumer<? super T,Integer> action)
action - 操作public Optional<T> findFirst(Predicate<? super T> predicate)
predicate - 断言public Integer findFirstIdx(Predicate<? super T> predicate)
predicate - 断言public Optional<T> findLast(Predicate<? super T> predicate)
predicate - 断言public Integer findLastIdx(Predicate<? super T> predicate)
predicate - 断言public Steam<T> reverseSorted(Comparator<T> comparator)
comparator - a Comparator object@SafeVarargs public final Steam<T> unshift(T... obj)
obj - 元素public <U,R> Steam<R> zip(Iterable<U> other, BiFunction<? super T,? super U,? extends R> zipper)
U - 给定的迭代对象类型R - 合并后的结果对象类型other - 给定的迭代器zipper - 两个元素的合并器public <R> Steam<T> filterContains(Function<? super T,? extends R> mapper, Iterable<T> others)
filter(Function, Object)R - 操作返回值类型others - 另一可迭代对象mapper - 操作public Steam<T> splice(int start, int deleteCount, T... items)
start - 起始下标deleteCount - 删除个数,正整数items - 放入值public Steam<Steam<T>> split(int batchSize)
形如:[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
batchSize - 指定长度, 正整数public Steam<List<T>> splitList(int batchSize)
形如:[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
batchSize - 指定长度, 正整数public I filter(Predicate<? super T> predicate)
过滤元素,返回与指定断言匹配的元素组成的流 这是一个无状态中间操作
public IntStream mapToInt(ToIntFunction<? super T> mapper)
和Stream.map(Function)一样,只不过函数的返回值必须为int类型
这是一个无状态中间操作
public LongStream mapToLong(ToLongFunction<? super T> mapper)
和Stream.map(Function)一样,只不过函数的返回值必须为long类型
这是一个无状态中间操作
public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)
和Stream.map(Function)一样,只不过函数的返回值必须为double类型
这是一个无状态中间操作
mapToDouble 在接口中 Stream<T>public IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流 这是一个无状态中间操作
flatMapToInt 在接口中 Stream<T>public LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流 这是一个无状态中间操作
flatMapToLong 在接口中 Stream<T>public DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
扩散流操作,可能影响流元素个数,将原有流元素执行mapper操作,返回多个流所有元素组成的流 这是一个无状态中间操作
flatMapToDouble 在接口中 Stream<T>public I distinct()
返回一个具有去重特征的流 非并行流(顺序流)下对于重复元素,保留遇到顺序中最先出现的元素,并行流情况下不能保证具体保留哪一个 这是一个有状态中间操作
public I sorted()
返回一个元素按自然顺序排序的流
如果此流的元素不是Comparable ,则在执行终端操作时可能会抛出 java.lang.ClassCastException
对于顺序流,排序是稳定的。 对于无序流,没有稳定性保证。
这是一个有状态中间操作
public I sorted(Comparator<? super T> comparator)
返回一个元素按指定的Comparator排序的流
如果此流的元素不是Comparable ,则在执行终端操作时可能会抛出java.lang.ClassCastException
对于顺序流,排序是稳定的。 对于无序流,没有稳定性保证。
这是一个有状态中间操作
public I peek(Consumer<? super T> action)
返回与指定函数将元素作为参数执行后组成的流。 这是一个无状态中间操作
peek 在接口中 Stream<T>
.of("one", "two", "three", "four")
.filter(e -> e.length() > 3)
.peek(e -> System.out.println("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e))
.collect(Collectors.toList());
public I skip(long n)
返回丢弃前面n个元素后的剩余元素组成的流,如果当前元素个数小于n,则返回一个元素为空的流 这是一个有状态中间操作
public void forEach(Consumer<? super T> action)
对流里面的每一个元素执行一个操作 这是一个终端操作
public void forEachOrdered(Consumer<? super T> action)
对流里面的每一个元素按照顺序执行一个操作 这是一个终端操作
forEachOrdered 在接口中 Stream<T>public <A> A[] toArray(IntFunction<A[]> generator)
返回一个包含此流元素的指定的数组,例如以下代码编译正常,但运行时会抛出 ArrayStoreException
String[] strings = Stream.<Integer>builder().add(1).build().toArray(String[]::new); public T reduce(T identity,
BinaryOperator<T> accumulator)
对元素进行聚合,并返回聚合后的值,相当于在for循环里写sum=sum+ints[i]
这是一个终端操作
求和、最小值、最大值、平均值和转换成一个String字符串均为聚合操作
例如这里对int进行求和可以写成:
Integer sum = integers.reduce(0, (a, b) -> a+b);
或者写成:
Integer sum = integers.reduce(0, Integer::sum);
public Optional<T> reduce(BinaryOperator<T> accumulator)
对元素进行聚合,并返回聚合后用 Optional包裹的值,相当于在for循环里写sum=sum+ints[i]
该操作相当于:
boolean foundAny = false;
T result = null;
for (T element : this stream) {
if (!foundAny) {
foundAny = true;
result = element;
}
else
result = accumulator.apply(result, element);
}
return foundAny ? Optional.of(result) : Optional.empty();
但它不局限于顺序执行,例如并行流等情况下
这是一个终端操作
Optional<Integer> reduce = Stream.<Integer>builder().add(1).add(1).build().reduce((a, b) -> null);
reduce 在接口中 Stream<T>reduce(Object, BinaryOperator),
min(Comparator),
max(Comparator)public <U> U reduce(U identity,
BiFunction<U,? super T,U> accumulator,
BinaryOperator<U> combiner)
对元素进行聚合,并返回聚合后的值,并行流时聚合拿到的初始值不稳定 这是一个终端操作
reduce 在接口中 Stream<T>reduce(BinaryOperator),
reduce(Object, BinaryOperator)public <R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)
对元素进行收集,并返回收集后的容器 这是一个终端操作
public <R,A> R collect(Collector<? super T,A,R> collector)
对元素进行收集,并返回收集后的元素 这是一个终端操作
public Optional<T> min(Comparator<? super T> comparator)
获取最小值
public Optional<T> max(Comparator<? super T> comparator)
获取最大值
public boolean anyMatch(Predicate<? super T> predicate)
判断是否有任何一个元素满足给定断言
public boolean allMatch(Predicate<? super T> predicate)
判断是否所有元素满足给定断言
public boolean noneMatch(Predicate<? super T> predicate)
判断是否没有元素满足给定断言
public Iterator<T> iterator()
返回流的迭代器
iterator 在接口中 Iterable<T>iterator 在接口中 BaseStream<T,Stream<T>>public Spliterator<T> spliterator()
返回流的拆分器
spliterator 在接口中 Iterable<T>spliterator 在接口中 BaseStream<T,Stream<T>>public boolean isParallel()
返回流的并行状态
isParallel 在接口中 BaseStream<T,Stream<T>>public I sequential()
返回一个串行流,该方法可以将并行流转换为串行流
sequential 在接口中 BaseStream<T,Stream<T>>public I parallel()
将流转换为并行
parallel 在接口中 BaseStream<T,Stream<T>>public I unordered()
返回一个无序流(无手动排序)
标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能
unordered 在接口中 BaseStream<T,Stream<T>>public I onClose(Runnable closeHandler)
在流关闭时执行操作
onClose 在接口中 BaseStream<T,Stream<T>>public void close()
关闭流
close 在接口中 AutoCloseableclose 在接口中 BaseStream<T,Stream<T>>AutoCloseable.close()Copyright © 2023 dromara. All rights reserved.