minglipro/mingli-utils
minglipro/mingli-utils
1
1
Fork 0
generated from mingliqiye/lib-tem
Code Issues Pull Requests Packages Projects Releases 23 Wiki Activity

feat(foreach): 增加带有提前终止功能的遍历方法并优化代码结构

Browse Source 
- 新增 forEachB 系列函数，支持在遍历过程中提前终止
- 为数组和集合添加专门的 forEach 和 forEachB 函数
- 优化现有 forEach 函数的实现，提高性能
- 添加针对 Map 类型的 forEachMap 和 forEachMapB 函数
- 更新函数注释，明确参数和返回值的含义
This commit is contained in:
Armamem0t 2025-09-15 12:45:16 +08:00
parent 33999bf4c6
commit f9e96fccd3
Signed by: minglipro
GPG Key ID: 5F355A77B22AA93B
1 changed files with 406 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

452
src/main/kotlin/com/mingliqiye/utils/foreach/ForEach.kt
View File

@ -16,24 +16,30 @@
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile ForEach.kt
* LastUpdate 2025-09-15 12:01:36
* LastUpdate 2025-09-15 12:44:46
* UpdateUser MingLiPro
*/
@file:JvmName("ForEach")
package com.mingliqiye.utils.foreach
import com.mingliqiye.utils.functions.P1Function
import com.mingliqiye.utils.functions.P1RFunction
import com.mingliqiye.utils.functions.P2Function
import com.mingliqiye.utils.functions.P2RFunction
import com.mingliqiye.utils.functions.*
/**
* 对给定的可迭代对象执行指定的操作，同时处理元素值和索引。
* 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。
*
* @param iterable 要遍历的可迭代对象
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param <T> 可迭代对象中元素的类型
*/
fun <T> forEach(
iterable: Iterable<T>, action: P2Function<in T, in Int>
) {
when (iterable) {
is RandomAccess if iterable is MutableList<*> -> {
// 如果是支持随机访问的可变列表，则使用索引遍历以提高性能
val list = iterable as MutableList<T>
for (i in list.indices) {
action.call(list[i], i)
@ -41,6 +47,7 @@ fun <T> forEach(
}
is MutableList<*> -> {
// 对于普通可变列表，使用迭代器进行遍历，并手动维护索引
var index = 0
val it = iterable.iterator()
while (it.hasNext()) {
@ -50,6 +57,7 @@ fun <T> forEach(
}
else -> {
// 对于其他类型的可迭代对象，使用增强 for 循环并手动维护索引
var index = 0
for (element in iterable) {
action.call(element, index)
@ -66,27 +74,39 @@ fun <T> forEach(
* @param iterable 要遍历的可迭代对象
* @param action 要对每个元素执行的操作，只接收元素值作为参数
* @param <T> 可迭代对象中元素的类型
**/
*/
fun <T> forEach(
iterable: Iterable<T>, action: P1Function<in T>
) {
if (iterable is RandomAccess) {
// 如果是支持随机访问的列表，则使用索引遍历以提高性能
val list = iterable as MutableList<T>
for (i in list.indices) {
action.call(list[i])
}
} else {
// 否则使用增强 for 循环进行遍历
for (element in iterable) {
action.call(element)
}
}
}
fun <T> forEach(
/**
* 对给定的可迭代对象执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
* 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。
*
* @param iterable 要遍历的可迭代对象
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
* @param <T> 可迭代对象中元素的类型
*/
fun <T> forEachB(
iterable: Iterable<T>, action: P2RFunction<in T, in Int, out Boolean>
) {
when (iterable) {
is RandomAccess if iterable is MutableList<*> -> {
// 如果是支持随机访问的可变列表，则使用索引遍历以提高性能
val list = iterable as MutableList<T>
for (i in list.indices) {
if (action.call(list[i], i)) return
@ -94,6 +114,7 @@ fun <T> forEach(
}
is MutableList<*> -> {
// 对于普通可变列表，使用迭代器进行遍历，并手动维护索引
var index = 0
val it = iterable.iterator()
while (it.hasNext()) {
@ -103,6 +124,7 @@ fun <T> forEach(
}
else -> {
// 对于其他类型的可迭代对象，使用增强 for 循环并手动维护索引
var index = 0
for (element in iterable) {
if (action.call(element, index)) return
@ -114,242 +136,574 @@ fun <T> forEach(
/**
* 对给定的可迭代对象执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
* 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。
*
* @param iterable 要遍历的可迭代对象
* @param action 要对每个元素执行的操作，只接收元素值作为参数
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
* @param <T> 可迭代对象中元素的类型
**/
fun <T> forEach(
*/
fun <T> forEachB(
iterable: Iterable<T>, action: P1RFunction<in T, out Boolean>
) {
if (iterable is RandomAccess) {
// 如果是支持随机访问的列表，则使用索引遍历以提高性能
val list = iterable as MutableList<T>
for (i in list.indices) {
if (action.call(list[i])) return
}
} else {
// 否则使用增强 for 循环进行遍历
for (element in iterable) {
if (action.call(element)) return
}
}
}
/**
* 对给定的数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param <T> 数组中元素的类型
*/
fun <T> forEach(
array: Array<T>, action: P2Function<in T, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
* @param <T> 数组中元素的类型
*/
fun <T> forEach(
array: Array<T>, action: P1Function<in T>
) {
forEach(array.toList(), action)
}
fun <T> forEach(
/**
* 对给定的数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
* @param <T> 数组中元素的类型
*/
fun <T> forEachB(
array: Array<T>, action: P2RFunction<in T, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun <T> forEach(
/**
* 对给定的数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
* @param <T> 数组中元素的类型
*/
fun <T> forEachB(
array: Array<T>, action: P1RFunction<in T, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的字节数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的字节数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
fun forEach(
array: ByteArray, action: P2Function<in Byte, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的字节数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的字节数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
*/
fun forEach(
array: ByteArray, action: P1Function<in Byte>
) {
forEach(array.toList(), action)
}
fun forEach(
/**
* 对给定的字节数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的字节数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: ByteArray, action: P2RFunction<in Byte, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun forEach(
/**
* 对给定的字节数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的字节数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: ByteArray, action: P1RFunction<in Byte, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的字符数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的字符数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
fun forEach(
array: CharArray, action: P2Function<in Char, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的字符数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的字符数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
*/
fun forEach(
array: CharArray, action: P1Function<in Char>
) {
forEach(array.toList(), action)
}
fun forEach(
/**
* 对给定的字符数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的字符数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: CharArray, action: P2RFunction<in Char, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun forEach(
/**
* 对给定的字符数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的字符数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: CharArray, action: P1RFunction<in Char, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的整型数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
fun forEach(
array: IntArray, action: P2Function<in Int, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的整型数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的整型数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
*/
fun forEach(
array: IntArray, action: P1Function<in Int>
) {
forEach(array.toList(), action)
}
fun forEach(
/**
* 对给定的整型数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: IntArray, action: P2RFunction<in Int, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun forEach(
/**
* 对给定的整型数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的整型数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: IntArray, action: P1RFunction<in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的长整型数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的长整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
fun forEach(
array: LongArray, action: P2Function<in Long, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的长整型数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的长整型数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
*/
fun forEach(
array: LongArray, action: P1Function<in Long>
) {
forEach(array.toList(), action)
}
fun forEach(
/**
* 对给定的长整型数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的长整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: LongArray, action: P2RFunction<in Long, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun forEach(
/**
* 对给定的长整型数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的长整型数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: LongArray, action: P1RFunction<in Long, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的短整型数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的短整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
fun forEach(
array: ShortArray, action: P2Function<in Short, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的短整型数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的短整型数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
*/
fun forEach(
array: ShortArray, action: P1Function<in Short>
) {
forEach(array.toList(), action)
}
fun forEach(
/**
* 对给定的短整型数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的短整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: ShortArray, action: P2RFunction<in Short, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun forEach(
/**
* 对给定的短整型数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的短整型数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: ShortArray, action: P1RFunction<in Short, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的浮点数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的浮点数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
fun forEach(
array: FloatArray, action: P2Function<in Float, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的浮点数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的浮点数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
*/
fun forEach(
array: FloatArray, action: P1Function<in Float>
) {
forEach(array.toList(), action)
}
fun forEach(
/**
* 对给定的浮点数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的浮点数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: FloatArray, action: P2RFunction<in Float, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun forEach(
/**
* 对给定的浮点数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的浮点数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: FloatArray, action: P1RFunction<in Float, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的双精度浮点数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
fun forEach(
array: DoubleArray, action: P2Function<in Double, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的双精度浮点数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
*/
fun forEach(
array: DoubleArray, action: P1Function<in Double>
) {
forEach(array.toList(), action)
}
fun forEach(
/**
* 对给定的双精度浮点数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: DoubleArray, action: P2RFunction<in Double, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun forEach(
/**
* 对给定的双精度浮点数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: DoubleArray, action: P1RFunction<in Double, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的布尔数组执行指定的操作，同时处理元素值和索引。
*
* @param array 要遍历的布尔数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
fun forEach(
array: BooleanArray, action: P2Function<in Boolean, in Int>
) {
forEach(array.toList(), action)
}
/**
* 对给定的布尔数组执行指定的操作，仅处理元素值。
*
* @param array 要遍历的布尔数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数
*/
fun forEach(
array: BooleanArray, action: P1Function<in Boolean>
) {
forEach(array.toList(), action)
}
fun forEach(
/**
* 对给定的布尔数组执行指定的操作，同时处理元素值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的布尔数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: BooleanArray, action: P2RFunction<in Boolean, in Int, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
fun forEach(
/**
* 对给定的布尔数组执行指定的操作，仅处理元素值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的布尔数组
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: BooleanArray, action: P1RFunction<in Boolean, out Boolean>
) {
forEach(array.toList(), action)
forEachB(array.toList(), action)
}
/**
* 对给定的键值对集合执行指定的操作，同时处理键、值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的键值对集合
* @param action 要对每个键值对执行的操作，接收键、值和索引作为参数，返回 Boolean 表示是否提前终止
* @param <K> 键的类型
* @param <V> 值的类型
* @param <A> 集合的具体类型
*/
fun <K, V, A : Collection<Map.Entry<K, V>>> forEachB(
array: A, action: P3RFunction<in K, in V, in Int, out Boolean>
) {
forEachB(array, P2RFunction<Map.Entry<K, V>, Int, Boolean> { p1, p2 -> action.call(p1.key, p1.value, p2) })
}
/**
* 对给定的映射执行指定的操作，同时处理键、值和索引。
* 如果操作返回 true，则提前终止遍历。
*
* @param map 要遍历的映射
* @param action 要对每个键值对执行的操作，接收键、值和索引作为参数，返回 Boolean 表示是否提前终止
* @param <K> 键的类型
* @param <V> 值的类型
* @param <A> 映射的具体类型
*/
fun <K, V, A : Map<K, V>> forEachB(
map: A, action: P3RFunction<in K, in V, in Int, out Boolean>
) {
forEachB(map.entries, P2RFunction<Map.Entry<K, V>, Int, Boolean> { p1, p2 -> action.call(p1.key, p1.value, p2) })
}
/**
* 对给定的键值对集合执行指定的操作，仅处理键和值。
*
* @param array 要遍历的键值对集合
* @param action 要对每个键值对执行的操作，接收键和值作为参数
* @param <K> 键的类型
* @param <V> 值的类型
* @param <A> 集合的具体类型
*/
fun <K, V, A : Collection<Map.Entry<K, V>>> forEachMap(
array: A, action: P2Function<in K, in V>
) {
forEach(array, P1Function<Map.Entry<K, V>> { p1 -> action.call(p1.key, p1.value) })
}
/**
* 对给定的映射执行指定的操作，仅处理键和值。
*
* @param map 要遍历的映射
* @param action 要对每个键值对执行的操作，接收键和值作为参数
* @param <K> 键的类型
* @param <V> 值的类型
* @param <A> 映射的具体类型
*/
fun <K, V, A : Map<K, V>> forEachMap(
map: A, action: P2Function<in K, in V>
) {
forEach(map.entries, P1Function<Map.Entry<K, V>> { p1 -> action.call(p1.key, p1.value) })
}
/**
* 对给定的键值对集合执行指定的操作，仅处理键和值。
* 如果操作返回 true，则提前终止遍历。
*
* @param array 要遍历的键值对集合
* @param action 要对每个键值对执行的操作，接收键和值作为参数，返回 Boolean 表示是否提前终止
* @param <K> 键的类型
* @param <V> 值的类型
* @param <A> 集合的具体类型
*/
fun <K, V, A : Collection<Map.Entry<K, V>>> forEachMapB(
array: A, action: P2RFunction<in K, in V, out Boolean>
) {
forEachB(array, P1RFunction<Map.Entry<K, V>, Boolean> { p1 -> action.call(p1.key, p1.value) })
}
/**
* 对给定的映射执行指定的操作，仅处理键和值。
* 如果操作返回 true，则提前终止遍历。
*
* @param map 要遍历的映射
* @param action 要对每个键值对执行的操作，接收键和值作为参数，返回 Boolean 表示是否提前终止
* @param <K> 键的类型
* @param <V> 值的类型
* @param <A> 映射的具体类型
*/
fun <K, V, A : Map<K, V>> forEachMapB(
map: A, action: P2RFunction<in K, in V, out Boolean>
) {
forEachB(map.entries, P1RFunction<Map.Entry<K, V>, Boolean> { p1 -> action.call(p1.key, p1.value) })
}