From f9e96fccd3f1304e40680fb83cc0df38e94be0f4 Mon Sep 17 00:00:00 2001 From: minglipro Date: Mon, 15 Sep 2025 12:45:16 +0800 Subject: [PATCH] =?UTF-8?q?feat(foreach):=20=E5=A2=9E=E5=8A=A0=E5=B8=A6?= =?UTF-8?q?=E6=9C=89=E6=8F=90=E5=89=8D=E7=BB=88=E6=AD=A2=E5=8A=9F=E8=83=BD?= =?UTF-8?q?=E7=9A=84=E9=81=8D=E5=8E=86=E6=96=B9=E6=B3=95=E5=B9=B6=E4=BC=98?= =?UTF-8?q?=E5=8C=96=E4=BB=A3=E7=A0=81=E7=BB=93=E6=9E=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新增 forEachB 系列函数，支持在遍历过程中提前终止 - 为数组和集合添加专门的 forEach 和 forEachB 函数 - 优化现有 forEach 函数的实现，提高性能 - 添加针对 Map 类型的 forEachMap 和 forEachMapB 函数 - 更新函数注释，明确参数和返回值的含义 --- .../com/mingliqiye/utils/foreach/ForEach.kt | 458 ++++++++++++++++-- 1 file changed, 406 insertions(+), 52 deletions(-) diff --git a/src/main/kotlin/com/mingliqiye/utils/foreach/ForEach.kt b/src/main/kotlin/com/mingliqiye/utils/foreach/ForEach.kt index 2ee89fd..0d7c5c2 100644 --- a/src/main/kotlin/com/mingliqiye/utils/foreach/ForEach.kt +++ b/src/main/kotlin/com/mingliqiye/utils/foreach/ForEach.kt @@ -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 可迭代对象中元素的类型 + */ fun forEach( iterable: Iterable, action: P2Function ) { when (iterable) { is RandomAccess if iterable is MutableList<*> -> { + // 如果是支持随机访问的可变列表，则使用索引遍历以提高性能 val list = iterable as MutableList for (i in list.indices) { action.call(list[i], i) @@ -41,6 +47,7 @@ fun forEach( } is MutableList<*> -> { + // 对于普通可变列表，使用迭代器进行遍历，并手动维护索引 var index = 0 val it = iterable.iterator() while (it.hasNext()) { @@ -50,6 +57,7 @@ fun forEach( } else -> { + // 对于其他类型的可迭代对象，使用增强 for 循环并手动维护索引 var index = 0 for (element in iterable) { action.call(element, index) @@ -64,29 +72,41 @@ fun forEach( * 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。 * * @param iterable 要遍历的可迭代对象 - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param 可迭代对象中元素的类型 - **/ + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param 可迭代对象中元素的类型 + */ fun forEach( iterable: Iterable, action: P1Function ) { if (iterable is RandomAccess) { + // 如果是支持随机访问的列表，则使用索引遍历以提高性能 val list = iterable as MutableList for (i in list.indices) { action.call(list[i]) } } else { + // 否则使用增强 for 循环进行遍历 for (element in iterable) { action.call(element) } } } -fun forEach( +/** + * 对给定的可迭代对象执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。 + * + * @param iterable 要遍历的可迭代对象 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + * @param 可迭代对象中元素的类型 + */ +fun forEachB( iterable: Iterable, action: P2RFunction ) { when (iterable) { is RandomAccess if iterable is MutableList<*> -> { + // 如果是支持随机访问的可变列表，则使用索引遍历以提高性能 val list = iterable as MutableList for (i in list.indices) { if (action.call(list[i], i)) return @@ -94,6 +114,7 @@ fun forEach( } is MutableList<*> -> { + // 对于普通可变列表，使用迭代器进行遍历，并手动维护索引 var index = 0 val it = iterable.iterator() while (it.hasNext()) { @@ -103,6 +124,7 @@ fun forEach( } else -> { + // 对于其他类型的可迭代对象，使用增强 for 循环并手动维护索引 var index = 0 for (element in iterable) { if (action.call(element, index)) return @@ -114,242 +136,574 @@ fun forEach( /** * 对给定的可迭代对象执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 * 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。 * * @param iterable 要遍历的可迭代对象 - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param 可迭代对象中元素的类型 - **/ -fun forEach( + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + * @param 可迭代对象中元素的类型 + */ +fun forEachB( iterable: Iterable, action: P1RFunction ) { if (iterable is RandomAccess) { + // 如果是支持随机访问的列表，则使用索引遍历以提高性能 val list = iterable as MutableList 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 数组中元素的类型 + */ fun forEach( array: Array, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param 数组中元素的类型 + */ fun forEach( array: Array, action: P1Function ) { forEach(array.toList(), action) } - -fun forEach( +/** + * 对给定的数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + * @param 数组中元素的类型 + */ +fun forEachB( array: Array, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + * @param 数组中元素的类型 + */ +fun forEachB( array: Array, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } - +/** + * 对给定的字节数组执行指定的操作，同时处理元素值和索引。 + * + * @param array 要遍历的字节数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ fun forEach( array: ByteArray, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的字节数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的字节数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + */ fun forEach( array: ByteArray, action: P1Function ) { forEach(array.toList(), action) } - -fun forEach( +/** + * 对给定的字节数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的字节数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: ByteArray, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的字节数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的字节数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: ByteArray, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } +/** + * 对给定的字符数组执行指定的操作，同时处理元素值和索引。 + * + * @param array 要遍历的字符数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ fun forEach( array: CharArray, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的字符数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的字符数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + */ fun forEach( array: CharArray, action: P1Function ) { forEach(array.toList(), action) } -fun forEach( +/** + * 对给定的字符数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的字符数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: CharArray, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的字符数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的字符数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: CharArray, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } +/** + * 对给定的整型数组执行指定的操作，同时处理元素值和索引。 + * + * @param array 要遍历的整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ fun forEach( array: IntArray, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的整型数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的整型数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + */ fun forEach( array: IntArray, action: P1Function ) { forEach(array.toList(), action) } -fun forEach( +/** + * 对给定的整型数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: IntArray, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的整型数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的整型数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: IntArray, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } +/** + * 对给定的长整型数组执行指定的操作，同时处理元素值和索引。 + * + * @param array 要遍历的长整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ fun forEach( array: LongArray, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的长整型数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的长整型数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + */ fun forEach( array: LongArray, action: P1Function ) { forEach(array.toList(), action) } -fun forEach( +/** + * 对给定的长整型数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的长整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: LongArray, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的长整型数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的长整型数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: LongArray, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } +/** + * 对给定的短整型数组执行指定的操作，同时处理元素值和索引。 + * + * @param array 要遍历的短整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ fun forEach( array: ShortArray, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的短整型数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的短整型数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + */ fun forEach( array: ShortArray, action: P1Function ) { forEach(array.toList(), action) } -fun forEach( +/** + * 对给定的短整型数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的短整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: ShortArray, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的短整型数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的短整型数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: ShortArray, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } +/** + * 对给定的浮点数组执行指定的操作，同时处理元素值和索引。 + * + * @param array 要遍历的浮点数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ fun forEach( array: FloatArray, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的浮点数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的浮点数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + */ fun forEach( array: FloatArray, action: P1Function ) { forEach(array.toList(), action) } -fun forEach( +/** + * 对给定的浮点数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的浮点数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: FloatArray, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的浮点数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的浮点数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: FloatArray, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } +/** + * 对给定的双精度浮点数组执行指定的操作，同时处理元素值和索引。 + * + * @param array 要遍历的双精度浮点数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ fun forEach( array: DoubleArray, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的双精度浮点数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的双精度浮点数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + */ fun forEach( array: DoubleArray, action: P1Function ) { forEach(array.toList(), action) } -fun forEach( +/** + * 对给定的双精度浮点数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的双精度浮点数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: DoubleArray, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的双精度浮点数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的双精度浮点数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: DoubleArray, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } +/** + * 对给定的布尔数组执行指定的操作，同时处理元素值和索引。 + * + * @param array 要遍历的布尔数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ fun forEach( array: BooleanArray, action: P2Function ) { forEach(array.toList(), action) } +/** + * 对给定的布尔数组执行指定的操作，仅处理元素值。 + * + * @param array 要遍历的布尔数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + */ fun forEach( array: BooleanArray, action: P1Function ) { forEach(array.toList(), action) } -fun forEach( +/** + * 对给定的布尔数组执行指定的操作，同时处理元素值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的布尔数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: BooleanArray, action: P2RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) } -fun forEach( +/** + * 对给定的布尔数组执行指定的操作，仅处理元素值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的布尔数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 表示是否提前终止 + */ +fun forEachB( array: BooleanArray, action: P1RFunction ) { - forEach(array.toList(), action) + forEachB(array.toList(), action) +} + +/** + * 对给定的键值对集合执行指定的操作，同时处理键、值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的键值对集合 + * @param action 要对每个键值对执行的操作，接收键、值和索引作为参数，返回 Boolean 表示是否提前终止 + * @param 键的类型 + * @param 值的类型 + * @param 集合的具体类型 + */ +fun >> forEachB( + array: A, action: P3RFunction +) { + forEachB(array, P2RFunction, Int, Boolean> { p1, p2 -> action.call(p1.key, p1.value, p2) }) +} + +/** + * 对给定的映射执行指定的操作，同时处理键、值和索引。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param map 要遍历的映射 + * @param action 要对每个键值对执行的操作，接收键、值和索引作为参数，返回 Boolean 表示是否提前终止 + * @param 键的类型 + * @param 值的类型 + * @param 映射的具体类型 + */ +fun > forEachB( + map: A, action: P3RFunction +) { + forEachB(map.entries, P2RFunction, Int, Boolean> { p1, p2 -> action.call(p1.key, p1.value, p2) }) +} + +/** + * 对给定的键值对集合执行指定的操作，仅处理键和值。 + * + * @param array 要遍历的键值对集合 + * @param action 要对每个键值对执行的操作，接收键和值作为参数 + * @param 键的类型 + * @param 值的类型 + * @param 集合的具体类型 + */ +fun >> forEachMap( + array: A, action: P2Function +) { + forEach(array, P1Function> { p1 -> action.call(p1.key, p1.value) }) +} + +/** + * 对给定的映射执行指定的操作，仅处理键和值。 + * + * @param map 要遍历的映射 + * @param action 要对每个键值对执行的操作，接收键和值作为参数 + * @param 键的类型 + * @param 值的类型 + * @param 映射的具体类型 + */ +fun > forEachMap( + map: A, action: P2Function +) { + forEach(map.entries, P1Function> { p1 -> action.call(p1.key, p1.value) }) +} + +/** + * 对给定的键值对集合执行指定的操作，仅处理键和值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param array 要遍历的键值对集合 + * @param action 要对每个键值对执行的操作，接收键和值作为参数，返回 Boolean 表示是否提前终止 + * @param 键的类型 + * @param 值的类型 + * @param 集合的具体类型 + */ +fun >> forEachMapB( + array: A, action: P2RFunction +) { + forEachB(array, P1RFunction, Boolean> { p1 -> action.call(p1.key, p1.value) }) +} + +/** + * 对给定的映射执行指定的操作，仅处理键和值。 + * 如果操作返回 true，则提前终止遍历。 + * + * @param map 要遍历的映射 + * @param action 要对每个键值对执行的操作，接收键和值作为参数，返回 Boolean 表示是否提前终止 + * @param 键的类型 + * @param 值的类型 + * @param 映射的具体类型 + */ +fun > forEachMapB( + map: A, action: P2RFunction +) { + forEachB(map.entries, P1RFunction, Boolean> { p1 -> action.call(p1.key, p1.value) }) }