T - 流中的元素类型S - WrappedStream的实现类类型public interface WrappedStream<T,S extends WrappedStream<T,S>> extends Stream<T>, Iterable<T>
Stream实例的包装器，用于增强原始的Stream，提供一些额外的中间与终端操作。
默认提供两个可用实现：
EasyStream：针对单元素的通用增强流实现；EntryStream：针对键值对类型元素的增强流实现；TerminableWrappedStream,
TransformableWrappedStream,
AbstractEnhancedWrappedStream,
EasyStream,
EntryStreamStream.Builder<T>| Modifier and Type | Field and Description |
|---|---|
static int |
NOT_FOUND_ELEMENT_INDEX
代表不存在的下标, 或者未找到元素时的下标
|
| Modifier and Type | Method and Description |
|---|---|
default boolean |
allMatch(Predicate<? super T> predicate)
判断是否所有元素满足给定断言
|
default boolean |
anyMatch(Predicate<? super T> predicate)
判断是否有任何一个元素满足给定断言
|
default void |
close()
关闭流
|
default <R,A> R |
collect(Collector<? super T,A,R> collector)
对元素进行收集，并返回收集后的元素
这是一个终端操作
|
default <R> R |
collect(Supplier<R> supplier,
BiConsumer<R,? super T> accumulator,
BiConsumer<R,R> combiner)
对元素进行收集，并返回收集后的容器
这是一个终端操作
|
default long |
count()
返回流元素个数
|
default S |
distinct()
返回一个具有去重特征的流 非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个
这是一个有状态中间操作
|
default EasyStream<T> |
easyStream()
转换为EasyStream
|
boolean |
equals(Object obj)
比较实例是否相等
|
default S |
filter(Predicate<? super T> predicate)
过滤元素，返回与指定断言匹配的元素组成的流
这是一个无状态中间操作
|
default Optional<T> |
findAny()
考虑性能，随便取一个，这里不是随机取一个，是随便取一个
|
default Optional<T> |
findFirst()
获取第一个元素
|
default DoubleStream |
flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流
这是一个无状态中间操作
|
default IntStream |
flatMapToInt(Function<? super T,? extends IntStream> mapper)
扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流
这是一个无状态中间操作
|
default LongStream |
flatMapToLong(Function<? super T,? extends LongStream> mapper)
扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流
这是一个无状态中间操作
|
default void |
forEach(Consumer<? super T> action)
对流里面的每一个元素执行一个操作
这是一个终端操作
|
default void |
forEachOrdered(Consumer<? super T> action)
对流里面的每一个元素按照顺序执行一个操作
这是一个终端操作
|
int |
hashCode()
获取当前实例的哈希值
|
default boolean |
isParallel()
返回流的并行状态
|
default Iterator<T> |
iterator()
返回流的迭代器
|
default S |
limit(long maxSize)
返回截取后面一些元素的流
这是一个短路状态中间操作
|
default DoubleStream |
mapToDouble(ToDoubleFunction<? super T> mapper)
和
EasyStream.map(Function)一样，只不过函数的返回值必须为double类型
这是一个无状态中间操作 |
default IntStream |
mapToInt(ToIntFunction<? super T> mapper)
和
EasyStream.map(Function)一样，只不过函数的返回值必须为int类型
这是一个无状态中间操作 |
default LongStream |
mapToLong(ToLongFunction<? super T> mapper)
和
EasyStream.map(Function)一样，只不过函数的返回值必须为long类型
这是一个无状态中间操作 |
default Optional<T> |
max(Comparator<? super T> comparator)
获取最大值
|
default Optional<T> |
min(Comparator<? super T> comparator)
获取最小值
|
default boolean |
noneMatch(Predicate<? super T> predicate)
判断是否没有元素满足给定断言
|
default S |
onClose(Runnable closeHandler)
在流关闭时执行操作
|
default S |
parallel()
将流转换为并行
|
default S |
peek(Consumer<? super T> action)
返回与指定函数将元素作为参数执行后组成的流。
|
default Optional<T> |
reduce(BinaryOperator<T> accumulator)
对元素进行聚合，并返回聚合后用
Optional包裹的值，相当于在for循环里写sum=sum+ints[i]
该操作相当于：
{@code
boolean foundAny = false;
T result = null;
for (T element : this unwrap) {
if (! |
default 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);
|
default <U> U |
reduce(U identity,
BiFunction<U,? super T,U> accumulator,
BinaryOperator<U> combiner)
对元素进行聚合，并返回聚合后的值，并行流时聚合拿到的初始值不稳定
这是一个终端操作
|
default S |
sequential()
返回一个串行流，该方法可以将并行流转换为串行流
|
default S |
skip(long n)
返回丢弃前面n个元素后的剩余元素组成的流，如果当前元素个数小于n，则返回一个元素为空的流
这是一个有状态中间操作
|
default S |
sorted()
返回一个元素按自然顺序排序的流
如果此流的元素不是
Comparable ，则在执行终端操作时可能会抛出 java.lang.ClassCastException
对于顺序流，排序是稳定的。 |
default S |
sorted(Comparator<? super T> comparator)
返回一个元素按指定的
Comparator排序的流
如果此流的元素不是Comparable ，则在执行终端操作时可能会抛出java.lang.ClassCastException
对于顺序流，排序是稳定的。 |
default Spliterator<T> |
spliterator()
返回流的拆分器
|
default Object[] |
toArray()
返回一个包含此流元素的数组
这是一个终端操作
|
default <A> A[] |
toArray(IntFunction<A[]> generator)
返回一个包含此流元素的指定的数组，例如以下代码编译正常，但运行时会抛出
ArrayStoreException
{@code String[] strings = Stream. |
String |
toString()
将当前实例转为字符串
|
default S |
unordered()
返回一个无序流(无手动排序)
标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能
|
Stream<T> |
unwrap()
获取被当前实例包装的流对象
|
S |
wrap(Stream<T> source)
将一个原始流包装为指定类型的增强流
若 source于当前实例包装的流并不相同，则该增强流与当前实例无关联关系 |
static final int NOT_FOUND_ELEMENT_INDEX
S wrap(Stream<T> source)
source于当前实例包装的流并不相同，则该增强流与当前实例无关联关系source - 被包装的流default IntStream mapToInt(ToIntFunction<? super T> mapper)
EasyStream.map(Function)一样，只不过函数的返回值必须为int类型
这是一个无状态中间操作default LongStream mapToLong(ToLongFunction<? super T> mapper)
EasyStream.map(Function)一样，只不过函数的返回值必须为long类型
这是一个无状态中间操作default DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)
EasyStream.map(Function)一样，只不过函数的返回值必须为double类型
这是一个无状态中间操作mapToDouble in interface Stream<T>mapper - 返回值为double类型的函数default IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)
flatMapToInt in interface Stream<T>mapper - 操作，返回IntStreamdefault LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)
flatMapToLong in interface Stream<T>mapper - 操作，返回LongStreamdefault DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
flatMapToDouble in interface Stream<T>mapper - 操作，返回DoubleStreamdefault S distinct()
default S sorted()
Comparable ，则在执行终端操作时可能会抛出 java.lang.ClassCastException
对于顺序流，排序是稳定的。 对于无序流，没有稳定性保证。
这是一个有状态中间操作default S sorted(Comparator<? super T> comparator)
Comparator排序的流
如果此流的元素不是Comparable ，则在执行终端操作时可能会抛出java.lang.ClassCastException
对于顺序流，排序是稳定的。 对于无序流，没有稳定性保证。
这是一个有状态中间操作default S peek(Consumer<? super T> action)
.of("one", "two", "three", "four")
.filter(e -> e.length() > 3)
.peek(e -> Console.log("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> Console.log("Mapped value: " + e))
.collect(Collectors.toList());
default S limit(long maxSize)
default S skip(long n)
default void forEachOrdered(Consumer<? super T> action)
forEachOrdered in interface Stream<T>action - 操作default Object[] toArray()
default <A> A[] toArray(IntFunction<A[]> generator)
ArrayStoreException
String[] strings = Stream.<Integer>builder().add(1).build().toArray(String[]::new); toArray in interface Stream<T>A - 给定的数组类型generator - 这里的IntFunction的参数是元素的个数，返回值为数组类型ArrayStoreException - 如果元素转换失败，例如不是该元素类型及其父类，则抛出该异常default T reduce(T identity, BinaryOperator<T> accumulator)
Integer sum = integers.reduce(0, (a, b) -> a+b);
或者写成:
Integer sum = integers.reduce(0, Integer::sum);
default Optional<T> reduce(BinaryOperator<T> accumulator)
Optional包裹的值，相当于在for循环里写sum=sum+ints[i]
该操作相当于：
boolean foundAny = false;
T result = null;
for (T element : this unwrap) {
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 in interface Stream<T>accumulator - 你想要的聚合操作Optional包裹的值NullPointerException - 如果给定的聚合操作中执行后结果为空，并用于下一次执行，则抛出该异常reduce(Object, BinaryOperator),
min(Comparator),
max(Comparator)default <U> U reduce(U identity,
BiFunction<U,? super T,U> accumulator,
BinaryOperator<U> combiner)
reduce in interface Stream<T>U - 初始值identity - 初始值accumulator - 累加器，具体为你要的聚合操作combiner - 用于并行流时组合多个结果reduce(BinaryOperator),
reduce(Object, BinaryOperator)default <R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)
collect in interface Stream<T>R - 用于收集元素的容器，大多是集合supplier - 提供初始值的函数式接口，一般可以传入构造参数accumulator - 具体收集操作combiner - 用于并行流时组合多个结果
List<Integer> collect = Stream.iterate(1, i -> ++i).limit(10).collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
default Optional<T> min(Comparator<? super T> comparator)
min in interface Stream<T>comparator - 一个用来比较大小的比较器Comparatordefault Optional<T> max(Comparator<? super T> comparator)
max in interface Stream<T>comparator - 一个用来比较大小的比较器Comparatordefault Spliterator<T> spliterator()
spliterator in interface BaseStream<T,Stream<T>>spliterator in interface Iterable<T>default boolean isParallel()
isParallel in interface BaseStream<T,Stream<T>>default S sequential()
sequential in interface BaseStream<T,Stream<T>>default S parallel()
parallel in interface BaseStream<T,Stream<T>>default S unordered()
标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能
unordered in interface BaseStream<T,Stream<T>>default S onClose(Runnable closeHandler)
onClose in interface BaseStream<T,Stream<T>>closeHandler - 在流关闭时执行的操作default void close()
close in interface AutoCloseableclose in interface BaseStream<T,Stream<T>>AutoCloseable.close()boolean equals(Object obj)
default EasyStream<T> easyStream()
Copyright © 2025. All rights reserved.