/* * Copyright 2026 mingliqiye * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * ProjectName FastBaseMapper.kt * ModuleName mingli-utils.main * CurrentFile SuperStream.java * LastUpdate 2026-10-26 23:22:18 * UpdateUser MingLiPro */ package com.mingliqiye.utils.stream; import com.mingliqiye.utils.collection.Collections; import com.mingliqiye.utils.functions.P1Function; import com.mingliqiye.utils.functions.P2Function; import org.jetbrains.annotations.NotNull; import java.lang.reflect.Array; import java.util.*; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.*; import java.util.stream.*; /** * SuperStream是一个增强版的Stream包装器,提供了更多的便捷方法和重载方法来处理各种数据类型的流操作。 * 它继承了Stream接口并实现了所有Stream的方法,同时添加了一些额外的便利功能。 */ public class SuperStream implements Stream { private final Stream stream; /** * 构造一个新的SuperStream实例 * * @param stream 被包装的基础Stream对象 */ private SuperStream(Stream stream) { this.stream = stream; } /** * 创建一个包含指定整数元素的SuperStream * * @param args 可变参数的整数值数组 * @return 包含指定整数的SuperStream实例 */ public static SuperStream of(int... args) { return of(Collections.newArrayLists(args)); } /** * 创建一个包含指定字节元素的SuperStream * * @param args 可变参数的字节数组 * @return 包含指定字节的SuperStream实例 */ public static SuperStream of(byte... args) { return of(Collections.newArrayLists(args)); } /** * 创建一个包含指定短整数元素的SuperStream * * @param args 可变参数的短整数数组 * @return 包含指定短整数的SuperStream实例 */ public static SuperStream of(short... args) { return of(Collections.newArrayLists(args)); } /** * 创建一个包含指定字符元素的SuperStream * * @param args 可变参数的字符数组 * @return 包含指定字符的SuperStream实例 */ public static SuperStream of(char... args) { return of(Collections.newArrayLists(args)); } /** * 创建一个包含指定长整数元素的SuperStream * * @param args 可变参数的长整数数组 * @return 包含指定长整数的SuperStream实例 */ public static SuperStream of(long... args) { return of(Collections.newArrayLists(args)); } /** * 创建一个包含指定布尔元素的SuperStream * * @param args 可变参数的布尔数组 * @return 包含指定布尔的SuperStream实例 */ public static SuperStream of(boolean... args) { return of(Collections.newArrayLists(args)); } /** * 创建一个包含指定浮点数元素的SuperStream * * @param args 可变参数的浮点数数组 * @return 包含指定浮点数的SuperStream实例 */ public static SuperStream of(float... args) { return of(Collections.newArrayLists(args)); } /** * 创建一个包含指定双精度浮点数元素的SuperStream * * @param args 可变参数的双精度浮点数数组 * @return 包含指定双精度浮点数的SuperStream实例 */ public static SuperStream of(double... args) { return of(Collections.newArrayLists(args)); } /** * 将现有的Stream包装成SuperStream * * @param stream 需要包装的Stream对象 * @param 流中元素的类型 * @return 包装后的SuperStream实例 */ public static SuperStream of(Stream stream) { return new SuperStream<>(stream); } /** * 创建一个包含指定数组元素的SuperStream,支持并行处理 * * @param ts 元素数组 * @param parallel 是否使用并行流 * @param 数组元素的类型 * @return 包含指定数组元素的SuperStream实例 */ public static SuperStream of(T[] ts, boolean parallel) { return of(Collections.newArrayLists(ts), parallel); } /** * 创建一个包含指定数组元素的SuperStream(默认串行) * * @param ts 元素数组 * @param 数组元素的类型 * @return 包含指定数组元素的SuperStream实例 */ public static SuperStream of(T[] ts) { return of(ts, false); } /** * 创建一个包含指定集合元素的SuperStream(默认串行) * * @param collection 包含元素的集合 * @param 集合元素的类型 * @return 包含指定集合元素的SuperStream实例 */ public static SuperStream of(Collection collection) { return of(collection, false); } /** * 创建一个包含指定Map键值对Entry的SuperStream(默认串行) * * @param map 源Map对象 * @param Map的键类型 * @param Map的值类型 * @return 包含Map Entry的SuperStream实例 */ public static SuperStream> of(Map map) { return of(map.entrySet(), false); } /** * 创建一个包含指定Map键值对Entry的SuperStream,支持并行处理 * * @param map 源Map对象 * @param parallel 是否使用并行流 * @param Map的键类型 * @param Map的值类型 * @return 包含Map Entry的SuperStream实例 */ public static SuperStream> of(Map map, boolean parallel) { return SuperStream.of(map.entrySet(), parallel); } /** * 创建一个包含指定集合元素的SuperStream,支持并行处理 * * @param stream 包含元素的集合 * @param parallel 是否使用并行流 * @param 集合元素的类型 * @return 包含指定集合元素的SuperStream实例 */ public static SuperStream of(Collection stream, boolean parallel) { return parallel ? SuperStream.of(stream.parallelStream()) : SuperStream.of(stream.stream()); } /** * 返回一个收集器,该收集器产生一个DoubleSummaryStatistics,描述输入元素的统计信息 * * @param mapper 用于将输入元素映射到double值的函数 * @param 输入元素的类型 * @return 产生DoubleSummaryStatistics的收集器 */ public static Collector summarizingDouble(@NotNull ToDoubleFunction mapper) { return Collectors.summarizingDouble(mapper); } /** * 返回一个收集器,该收集器产生一个LongSummaryStatistics,描述输入元素的统计信息 * * @param mapper 用于将输入元素映射到long值的函数 * @param 输入元素的类型 * @return 产生LongSummaryStatistics的收集器 */ public static Collector summarizingLong(@NotNull ToLongFunction mapper) { return Collectors.summarizingLong(mapper); } /** * 返回一个收集器,该收集器产生一个IntSummaryStatistics,描述输入元素的统计信息 * * @param mapper 用于将输入元素映射到int值的函数 * @param 输入元素的类型 * @return 产生IntSummaryStatistics的收集器 */ public static Collector summarizingInt(@NotNull ToIntFunction mapper) { return Collectors.summarizingInt(mapper); } /** * 返回一个收集器,该收集器将输入元素累积到ConcurrentMap中 * * @param keyMapper 用于产生键的映射函数 * @param valueMapper 用于产生值的映射函数 * @param mergeFunction 当键冲突时合并值的函数 * @param mapSupplier 用于创建新Map的供应函数 * @param 输入元素的类型 * @param 键的类型 * @param 值的类型 * @param Map的具体类型 * @return 产生ConcurrentMap的收集器 */ public static > Collector toConcurrentMap(@NotNull Function keyMapper, @NotNull Function valueMapper, @NotNull BinaryOperator mergeFunction, @NotNull Supplier mapSupplier) { return Collectors.toConcurrentMap(keyMapper, valueMapper, mergeFunction, mapSupplier); } /** * 返回一个收集器,该收集器将输入元素累积到ConcurrentMap中,使用BinaryOperator处理键冲突 * * @param keyMapper 用于产生键的映射函数 * @param valueMapper 用于产生值的映射函数 * @param mergeFunction 当键冲突时合并值的函数 * @param 输入元素的类型 * @param 键的类型 * @param 值的类型 * @return 产生ConcurrentMap的收集器 */ public static Collector> toConcurrentMap(@NotNull Function keyMapper, @NotNull Function valueMapper, @NotNull BinaryOperator mergeFunction) { return Collectors.toConcurrentMap(keyMapper, valueMapper, mergeFunction); } /** * 返回一个收集器,该收集器将输入元素累积到ConcurrentMap中,使用HashMap.merge处理键冲突 * * @param keyMapper 用于产生键的映射函数 * @param valueMapper 用于产生值的映射函数 * @param 输入元素的类型 * @param 键的类型 * @param 值的类型 * @return 产生ConcurrentMap的收集器 */ public static Collector> toConcurrentMap(@NotNull Function keyMapper, @NotNull Function valueMapper) { return Collectors.toConcurrentMap(keyMapper, valueMapper); } /** * 返回一个收集器,该收集器将输入元素累积到Map中 * * @param keyMapper 用于产生键的映射函数 * @param valueMapper 用于产生值的映射函数 * @param mergeFunction 当键冲突时合并值的函数 * @param mapSupplier 用于创建新Map的供应函数 * @param 输入元素的类型 * @param 键的类型 * @param 值的类型 * @param Map的具体类型 * @return 产生Map的收集器 */ public static > Collector toMap(@NotNull Function keyMapper, @NotNull Function valueMapper, @NotNull BinaryOperator mergeFunction, @NotNull Supplier mapSupplier) { return Collectors.toMap(keyMapper, valueMapper, mergeFunction, mapSupplier); } /** * 返回一个收集器,该收集器将输入元素累积到Map中,使用BinaryOperator处理键冲突 * * @param keyMapper 用于产生键的映射函数 * @param valueMapper 用于产生值的映射函数 * @param mergeFunction 当键冲突时合并值的函数 * @param 输入元素的类型 * @param 键的类型 * @param 值的类型 * @return 产生Map的收集器 */ public static Collector> toMap(@NotNull Function keyMapper, @NotNull Function valueMapper, @NotNull BinaryOperator mergeFunction) { return Collectors.toMap(keyMapper, valueMapper, mergeFunction); } /** * 返回一个收集器,该收集器将输入元素累积到Map中,使用HashMap.merge处理键冲突 * * @param keyMapper 用于产生键的映射函数 * @param valueMapper 用于产生值的映射函数 * @param 输入元素的类型 * @param 键的类型 * @param 值的类型 * @return 产生Map的收集器 */ public static Collector> toMap(@NotNull Function keyMapper, @NotNull Function valueMapper) { return Collectors.toMap(keyMapper, valueMapper); } /** * 返回一个收集器,该收集器根据谓词将输入元素分区到Map中 * * @param predicate 用于确定元素分区的谓词 * @param downstream 应用于分区结果的下游收集器 * @param 输入元素的类型 * @param 下游收集器的结果类型 * @param 下游收集器的累加器类型 * @return 产生分区Map的收集器 */ public static Collector> partitioningBy(@NotNull Predicate predicate, @NotNull Collector downstream) { return Collectors.partitioningBy(predicate, downstream); } /** * 返回一个收集器,该收集器根据谓词将输入元素分区到Map中 * * @param predicate 用于确定元素分区的谓词 * @param 输入元素的类型 * @return 产生分区Map的收集器 */ public static Collector>> partitioningBy(@NotNull Predicate predicate) { return Collectors.partitioningBy(predicate); } /** * 返回一个收集器,该收集器将输入元素按分类器分组到ConcurrentMap中 * * @param classifier 用于分类元素的函数 * @param mapFactory 用于创建Map的工厂函数 * @param downstream 应用于分组结果的下游收集器 * @param 输入元素的类型 * @param 分类键的类型 * @param 下游收集器的结果类型 * @param 下游收集器的累加器类型 * @param Map的具体类型 * @return 产生ConcurrentMap的收集器 */ public static > Collector groupingByConcurrent(@NotNull Function classifier, @NotNull Supplier mapFactory, @NotNull Collector downstream) { return Collectors.groupingByConcurrent(classifier, mapFactory, downstream); } /** * 返回一个收集器,该收集器将输入元素按分类器分组到ConcurrentMap中 * * @param classifier 用于分类元素的函数 * @param downstream 应用于分组结果的下游收集器 * @param 输入元素的类型 * @param 分类键的类型 * @param 下游收集器的累加器类型 * @param 下游收集器的结果类型 * @return 产生ConcurrentMap的收集器 */ public static Collector> groupingByConcurrent(@NotNull Function classifier, @NotNull Collector downstream) { return Collectors.groupingByConcurrent(classifier, downstream); } /** * 返回一个收集器,该收集器将输入元素按分类器分组到ConcurrentMap中 * * @param classifier 用于分类元素的函数 * @param 输入元素的类型 * @param 分类键的类型 * @return 产生ConcurrentMap的收集器 */ public static Collector>> groupingByConcurrent(@NotNull Function classifier) { return Collectors.groupingByConcurrent(classifier); } /** * 返回一个收集器,该收集器将输入元素按分类器分组到Map中 * * @param classifier 用于分类元素的函数 * @param mapFactory 用于创建Map的工厂函数 * @param downstream 应用于分组结果的下游收集器 * @param 输入元素的类型 * @param 分类键的类型 * @param 下游收集器的结果类型 * @param 下游收集器的累加器类型 * @param Map的具体类型 * @return 产生Map的收集器 */ public static > Collector groupingBy(@NotNull Function classifier, @NotNull Supplier mapFactory, @NotNull Collector downstream) { return Collectors.groupingBy(classifier, mapFactory, downstream); } /** * 返回一个收集器,该收集器将输入元素按分类器分组到Map中 * * @param classifier 用于分类元素的函数 * @param downstream 应用于分组结果的下游收集器 * @param 输入元素的类型 * @param 分类键的类型 * @param 下游收集器的累加器类型 * @param 下游收集器的结果类型 * @return 产生Map的收集器 */ public static Collector> groupingBy(@NotNull Function classifier, @NotNull Collector downstream) { return Collectors.groupingBy(classifier, downstream); } /** * 返回一个收集器,该收集器将输入元素按分类器分组到Map中 * * @param classifier 用于分类元素的函数 * @param 输入元素的类型 * @param 分类键的类型 * @return 产生Map的收集器 */ public static Collector>> groupingBy(@NotNull Function classifier) { return Collectors.groupingBy(classifier); } /** * 返回一个收集器,该收集器执行归约操作 * * @param identity 归约操作的初始值 * @param mapper 用于将输入元素映射到中间值的函数 * @param op 用于组合中间值的二元操作符 * @param 输入元素的类型 * @param 中间值和结果的类型 * @return 执行归约操作的收集器 */ public static Collector reducing(U identity, @NotNull Function mapper, @NotNull BinaryOperator op) { return Collectors.reducing(identity, mapper, op); } /** * 返回一个收集器,该收集器执行归约操作 * * @param op 用于组合元素的二元操作符 * @param 输入元素的类型 * @return 执行归约操作的收集器 */ public static Collector> reducing(@NotNull BinaryOperator op) { return Collectors.reducing(op); } /** * 返回一个收集器,该收集器执行归约操作 * * @param identity 归约操作的初始值 * @param op 用于组合元素的二元操作符 * @param 输入元素的类型 * @return 执行归约操作的收集器 */ public static Collector reducing(T identity, @NotNull BinaryOperator op) { return Collectors.reducing(identity, op); } /** * 返回一个收集器,该收集器计算输入元素的平均值 * * @param mapper 用于将输入元素映射到double值的函数 * @param 输入元素的类型 * @return 计算平均值的收集器 */ public static Collector averagingDouble(@NotNull ToDoubleFunction mapper) { return Collectors.averagingDouble(mapper); } /** * 返回一个收集器,该收集器计算输入元素的平均值 * * @param mapper 用于将输入元素映射到long值的函数 * @param 输入元素的类型 * @return 计算平均值的收集器 */ public static Collector averagingLong(@NotNull ToLongFunction mapper) { return Collectors.averagingLong(mapper); } /** * 返回一个收集器,该收集器计算输入元素的平均值 * * @param mapper 用于将输入元素映射到int值的函数 * @param 输入元素的类型 * @return 计算平均值的收集器 */ public static Collector averagingInt(@NotNull ToIntFunction mapper) { return Collectors.averagingInt(mapper); } /** * 返回一个收集器,该收集器计算输入元素的总和 * * @param mapper 用于将输入元素映射到double值的函数 * @param 输入元素的类型 * @return 计算总和的收集器 */ public static Collector summingDouble(@NotNull ToDoubleFunction mapper) { return Collectors.summingDouble(mapper); } /** * 返回一个收集器,该收集器计算输入元素的总和 * * @param mapper 用于将输入元素映射到long值的函数 * @param 输入元素的类型 * @return 计算总和的收集器 */ public static Collector summingLong(@NotNull ToLongFunction mapper) { return Collectors.summingLong(mapper); } /** * 返回一个收集器,该收集器计算输入元素的总和 * * @param mapper 用于将输入元素映射到int值的函数 * @param 输入元素的类型 * @return 计算总和的收集器 */ public static Collector summingInt(@NotNull ToIntFunction mapper) { return Collectors.summingInt(mapper); } /** * 返回一个收集器,该收集器根据比较器找到最大元素 * * @param comparator 用于比较元素的比较器 * @param 输入元素的类型 * @return 找到最大元素的收集器 */ public static Collector> maxBy(@NotNull Comparator comparator) { return Collectors.maxBy(comparator); } /** * 返回一个收集器,该收集器根据比较器找到最小元素 * * @param comparator 用于比较元素的比较器 * @param 输入元素的类型 * @return 找到最小元素的收集器 */ public static Collector> minBy(@NotNull Comparator comparator) { return Collectors.minBy(comparator); } /** * 返回一个收集器,该收集器计算输入元素的数量 * * @param 输入元素的类型 * @return 计算元素数量的收集器 */ public static Collector counting() { return Collectors.counting(); } /** * 返回一个收集器,该收集器在应用下游收集器后执行finisher转换 * * @param downstream 下游收集器 * @param finisher 在下游收集器完成后应用的finisher函数 * @param 输入元素的类型 * @param 下游收集器的累加器类型 * @param 下游收集器的结果类型 * @param 最终结果类型 * @return 执行转换的收集器 */ public static Collector collectingAndThen(@NotNull Collector downstream, @NotNull Function finisher) { return Collectors.collectingAndThen(downstream, finisher); } /** * 返回一个收集器,该收集器将输入元素映射后应用下游收集器 * * @param mapper 用于映射输入元素的函数 * @param downstream 应用于映射后元素的下游收集器 * @param 输入元素的类型 * @param 映射后元素的类型 * @param 下游收集器的累加器类型 * @param 下游收集器的结果类型 * @return 执行映射和收集的收集器 */ public static Collector mapping(@NotNull Function mapper, @NotNull Collector downstream) { return Collectors.mapping(mapper, downstream); } /** * 返回一个收集器,该收集器连接输入的字符序列 * * @param delimiter 分隔符 * @param prefix 前缀 * @param suffix 后缀 * @return 连接字符序列的收集器 */ public static Collector joining(@NotNull CharSequence delimiter, @NotNull CharSequence prefix, @NotNull CharSequence suffix) { return Collectors.joining(delimiter, prefix, suffix); } /** * 返回一个收集器,该收集器连接输入的字符序列 * * @param delimiter 分隔符 * @return 连接字符序列的收集器 */ public static Collector joining(@NotNull CharSequence delimiter) { return Collectors.joining(delimiter); } /** * 返回一个收集器,该收集器连接输入的字符序列 * * @return 连接字符序列的收集器 */ public static Collector joining() { return Collectors.joining(); } /** * 返回一个收集器,该收集器将输入元素累积到Set中 * * @param 输入元素的类型 * @return 产生Set的收集器 */ public static Collector> toSet() { return Collectors.toSet(); } /** * 返回一个收集器,该收集器将输入元素累积到List中 * * @param 输入元素的类型 * @return 产生List的收集器 */ public static Collector> toListCollector() { return Collectors.toList(); } /** * 返回一个收集器,该收集器将输入元素累积到指定类型的集合中 * * @param collectionFactory 用于创建集合的工厂函数 * @param 输入元素的类型 * @param 目标集合的具体类型 * @return 产生指定类型集合的收集器 */ public static > Collector toCollection(@NotNull Supplier collectionFactory) { return Collectors.toCollection(collectionFactory); } /** * 返回一个收集器,该收集器将输入元素累积到Map中,键由keyMapper提供,值为元素本身 * * @param keyMapper 用于产生键的映射函数 * @param 输入元素的类型 * @param 键的类型 * @return 产生Map的收集器 */ public static Collector> toMap(Function keyMapper) { return toMap(keyMapper, Function.identity()); } /** * 返回一个收集器,该收集器将Map.Entry类型的输入元素累积到Map中 * * @param 输入元素的类型(必须是Map.Entry) * @param 键的类型 * @param 值的类型 * @return 产生Map的收集器 */ public static , K, V> Collector> toMap() { return Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue); } /** * 对流中的每个元素应用过滤条件 * * @param predicate 用于测试元素是否满足条件的谓词 * @return 过滤后的SuperStream实例 */ public SuperStream filter(Predicate predicate) { return SuperStream.of(stream.filter(predicate)); } /** * 使用指定的收集器对流进行收集操作 * * @param collector 用于收集元素的收集器 * @param 收集结果的类型 * @param 收集器累加器的类型 * @return 收集操作的结果 */ public R collect(Collector collector) { return stream.collect(collector); } /** * 获取流的Spliterator * * @return 流的Spliterator实例 */ @NotNull public Spliterator spliterator() { return stream.spliterator(); } /** * 将每个元素映射为IntStream并展平结果 * * @param mapper 用于将元素映射为IntStream的函数 * @return 展平后的IntStream */ public IntStream flatMapToInt(Function mapper) { return stream.flatMapToInt(mapper); } /** * 检查流是否为并行流 * * @return 如果流是并行的则返回true,否则返回false */ public boolean isParallel() { return stream.isParallel(); } /** * 获取流的迭代器 * * @return 流的Iterator实例 */ @NotNull public Iterator iterator() { return stream.iterator(); } /** * 对流中的每个元素执行指定的动作 * * @param action 要执行的动作函数 */ public void forEach(P1Function action) { stream.forEach(action::call); } /** * 对流中的每个元素执行指定的动作,并传递索引 * * @param action 要执行的动作函数,接收元素和索引作为参数 */ public void forEach(P2Function action) { AtomicInteger i22 = new AtomicInteger(0); stream.forEach(i -> { action.call(i, i22.getAndAdd(1)); }); } /** * 对流中的每个元素执行指定的动作 * * @param action 要执行的动作函数 */ public void forEach(Consumer action) { stream.forEach(action); } /** * 将每个元素映射为Stream并展平结果 * * @param mapper 用于将元素映射为Stream的函数 * @param 映射后元素的类型 * @return 展平后的Stream实例 */ public Stream flatMap(Function> mapper) { return stream.flatMap(mapper); } /** * 返回一个串行流 * * @return 串行的SuperStream实例 */ @NotNull public SuperStream sequential() { return SuperStream.of(stream.sequential()); } /** * 跳过指定数量的元素 * * @param n 要跳过的元素数量 * @return 跳过元素后的SuperStream实例 */ public SuperStream skip(long n) { return SuperStream.of(stream.skip(n)); } /** * 使用指定的收集器对流进行收集操作 * * @param supplier 用于创建初始累加器的供应函数 * @param accumulator 用于将元素添加到累加器的操作 * @param combiner 用于合并两个累加器的操作 * @param 收集结果的类型 * @return 收集操作的结果 */ public R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner) { return stream.collect(supplier, accumulator, combiner); } /** * 返回一个并行流 * * @return 并行的SuperStream实例 */ @NotNull public SuperStream parallel() { return SuperStream.of(stream.parallel()); } /** * 将每个元素映射为DoubleStream并展平结果 * * @param mapper 用于将元素映射为DoubleStream的函数 * @return 展平后的DoubleStream */ public DoubleStream flatMapToDouble(Function mapper) { return stream.flatMapToDouble(mapper); } /** * 将流转换为指定类型的数组 * * @param generator 用于创建数组的函数 * @param 数组元素的类型 * @return 转换后的数组 */ @NotNull public A[] toArray(IntFunction generator) { return stream.toArray(generator); } /** * 查找流中的第一个元素 * * @return 包含第一个元素的Optional,如果流为空则返回空Optional */ @NotNull public Optional findFirst() { return stream.findFirst(); } /** * 返回一个无序流 * * @return 无序的SuperStream实例 */ @NotNull public SuperStream unordered() { return SuperStream.of(stream.unordered()); } /** * 根据比较器查找流中的最小元素 * * @param comparator 用于比较元素的比较器 * @return 包含最小元素的Optional,如果流为空则返回空Optional */ @NotNull public Optional min(Comparator comparator) { return stream.min(comparator); } /** * 查找流中的任意元素 * * @return 包含任意元素的Optional,如果流为空则返回空Optional */ @NotNull public Optional findAny() { return stream.findAny(); } /** * 注册一个关闭处理器,在流关闭时执行 * * @param closeHandler 关闭时要执行的Runnable * @return 添加了关闭处理器的SuperStream实例 */ @NotNull public SuperStream onClose(@NotNull Runnable closeHandler) { return SuperStream.of(stream.onClose(closeHandler)); } /** * 将每个元素映射为LongStream并展平结果 * * @param mapper 用于将元素映射为LongStream的函数 * @return 展平后的LongStream */ public LongStream flatMapToLong(Function mapper) { return stream.flatMapToLong(mapper); } /** * 将流转换为指定类型的数组 * * @param clazz 数组元素的Class对象 * @return 转换后的数组 */ @NotNull @SuppressWarnings("unchecked") public T[] toArray(Class clazz) { return stream.toArray(i -> (T[]) Array.newInstance(clazz, i)); } /** * 将流转换为Object数组 * * @return 转换后的Object数组 */ @NotNull public Object[] toArray() { return stream.toArray(); } /** * 按顺序对流中的每个元素执行指定的动作 * * @param action 要执行的动作函数 */ public void forEachOrdered(Consumer action) { stream.forEachOrdered(action); } /** * 关闭流并释放相关资源 */ public void close() { stream.close(); } /** * 对流执行归约操作 * * @param accumulator 用于组合元素的二元操作符 * @return 归约操作的结果,如果流为空则返回空Optional */ @NotNull public Optional reduce(BinaryOperator accumulator) { return stream.reduce(accumulator); } /** * 返回一个根据指定比较器排序的流 * * @param comparator 用于比较元素的比较器 * @return 排序后的SuperStream实例 */ public SuperStream sorted(Comparator comparator) { return SuperStream.of(stream.sorted(comparator)); } /** * 检查流中的所有元素是否都满足给定的谓词 * * @param predicate 用于测试元素的谓词 * @return 如果所有元素都满足谓词或流为空则返回true,否则返回false */ public boolean allMatch(Predicate predicate) { return stream.allMatch(predicate); } /** * 返回一个自然排序的流 * * @return 排序后的SuperStream实例 */ public SuperStream sorted() { return SuperStream.of(stream.sorted()); } /** * 计算流中元素的数量 * * @return 流中元素的数量 */ public long count() { return stream.count(); } /** * 将流中的每个元素通过映射函数转换 * * @param mapper 用于转换元素的映射函数 * @param 映射后元素的类型 * @return 转换后的SuperStream实例 */ public SuperStream map(Function mapper) { return SuperStream.of(stream.map(mapper)); } /** * 对流执行归约操作 * * @param identity 归约操作的初始值 * @param accumulator 用于组合元素的二元操作符 * @return 归约操作的结果 */ public T reduce(T identity, BinaryOperator accumulator) { return stream.reduce(identity, accumulator); } /** * 检查流中的所有元素都不满足给定的谓词 * * @param predicate 用于测试元素的谓词 * @return 如果所有元素都不满足谓词则返回true,否则返回false */ public boolean noneMatch(Predicate predicate) { return stream.noneMatch(predicate); } /** * 返回一个去重后的流 * * @return 去重后的SuperStream实例 */ public SuperStream distinct() { return SuperStream.of(stream.distinct()); } /** * 根据比较器查找流中的最大元素 * * @param comparator 用于比较元素的比较器 * @return 包含最大元素的Optional,如果流为空则返回空Optional */ @NotNull public Optional max(Comparator comparator) { return stream.max(comparator); } /** * 将流中的每个元素映射为double值 * * @param mapper 用于映射元素为double值的函数 * @return 映射后的DoubleStream */ public DoubleStream mapToDouble(ToDoubleFunction mapper) { return stream.mapToDouble(mapper); } /** * 限制流中元素的数量 * * @param maxSize 最大元素数量 * @return 限制后的SuperStream实例 */ public SuperStream limit(long maxSize) { return SuperStream.of(stream.limit(maxSize)); } /** * 将流中的每个元素映射为long值 * * @param mapper 用于映射元素为long值的函数 * @return 映射后的LongStream */ public LongStream mapToLong(ToLongFunction mapper) { return stream.mapToLong(mapper); } /** * 对流中的每个元素执行动作,然后返回原流 * * @param action 要执行的动作函数 * @return 原始的SuperStream实例 */ public SuperStream peek(Consumer action) { return SuperStream.of(stream.peek(action)); } /** * 对流执行归约操作 * * @param identity 归约操作的初始值 * @param accumulator 用于组合元素的二元操作符 * @param combiner 用于合并累加器的二元操作符 * @param 累加器和结果的类型 * @return 归约操作的结果 */ public U reduce(U identity, BiFunction accumulator, BinaryOperator combiner) { return stream.reduce(identity, accumulator, combiner); } /** * 将流中的每个元素映射为int值 * * @param mapper 用于映射元素为int值的函数 * @return 映射后的IntStream */ public IntStream mapToInt(ToIntFunction mapper) { return stream.mapToInt(mapper); } /** * 检查流中是否有任何元素满足给定的谓词 * * @param predicate 用于测试元素的谓词 * @return 如果有任何元素满足谓词则返回true,否则返回false */ public boolean anyMatch(Predicate predicate) { return stream.anyMatch(predicate); } /** * 获取被包装的基础Stream对象 * * @return 基础Stream对象 */ public Stream getStream() { return stream; } /** * 将流中的元素收集到Map中,使用指定的键和值映射函数 * * @param keyMapper 用于生成键的映射函数 * @param valueMapper 用于生成值的映射函数 * @param 键的类型 * @param 值的类型 * @return 包含映射结果的Map */ public Map toAMap(Function keyMapper, Function valueMapper) { return collect(toMap(keyMapper, valueMapper)); } /** * 将流中的元素收集到Map中,使用指定的键映射函数,值为元素本身 * * @param keyMapper 用于生成键的映射函数 * @param 键的类型 * @return 包含映射结果的Map */ public Map toAMap(Function keyMapper) { return collect(toMap(keyMapper)); } /** * 将流中的元素收集到List中 * * @return 包含流中所有元素的List */ public List toAList() { return collect(toListCollector()); } }