Compare commits

...
Author SHA1 Message Date
minglipro 0b1aac8ecc Merge pull request 'refactor(mybatis): 更新类型处理器以支持 JDBC 类型参数为 null' (#7) from dev into master
Reviewed-on: #7
2025-09-15 13:55:22 +08:00
minglipro 9a6c6cd662 refactor(mybatis): 更新类型处理器以支持 JDBC 类型参数为 null
- 修改 DateTimeTypeHandler、MysqlUUIDBinaryTypeHandler 和 UUIDTypeHandler
- 将 setNonNullParameter 方法的 jdbcType 参数变更为可空类型
- 更新方法实现以适应新的可空参数
- 提升代码的健壮性和灵活性,允许在某些情况下不指定 JDBC 类型
2025-09-15 13:55:01 +08:00
minglipro 3d1f249970 Merge pull request 'dev' (#6) from dev into master
Reviewed-on: #6
2025-09-15 12:46:12 +08:00
minglipro b329953377 feat(foreach): 增加带有提前终止功能的遍历方法并优化代码结构
- 新增 forEachB 系列函数,支持在遍历过程中提前终止
- 为数组和集合添加专门的 forEach 和 forEachB 函数
- 优化现有 forEach 函数的实现,提高性能
- 添加针对 Map 类型的 forEachMap 和 forEachMapB 函数
- 更新函数注释,明确参数和返回值的含义
2025-09-15 12:45:59 +08:00
minglipro f9e96fccd3 feat(foreach): 增加带有提前终止功能的遍历方法并优化代码结构
- 新增 forEachB 系列函数,支持在遍历过程中提前终止
- 为数组和集合添加专门的 forEach 和 forEachB 函数
- 优化现有 forEach 函数的实现,提高性能
- 添加针对 Map 类型的 forEachMap 和 forEachMapB 函数
- 更新函数注释,明确参数和返回值的含义
2025-09-15 12:45:16 +08:00
5 changed files with 417 additions and 63 deletions
+2 -2
View File
@@ -16,10 +16,10 @@
# ProjectName mingli-utils
# ModuleName mingli-utils
# CurrentFile gradle.properties
# LastUpdate 2025-09-15 12:01:24
# LastUpdate 2025-09-15 13:54:50
# UpdateUser MingLiPro
#
JDKVERSIONS=1.8
GROUPSID=com.mingliqiye.utils
ARTIFACTID=mingli-utils
VERSIONS=4.0.2
VERSIONS=4.0.4
@@ -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)
@@ -64,29 +72,41 @@ fun <T> forEach(
* 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。
*
* @param iterable 要遍历的可迭代对象
* @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param <T> 可迭代对象中元素的类型
**/
* @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 <T> 可迭代对象中元素的类型
**/
fun <T> forEach(
* @param action 要对每个元素执行的操作,只接收元素值作为参数,返回 Boolean 表示是否提前终止
* @param <T> 可迭代对象中元素的类型
*/
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) })
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile DateTimeTypeHandler.kt
* LastUpdate 2025-09-14 18:19:29
* LastUpdate 2025-09-15 13:53:53
* UpdateUser MingLiPro
*/
@file:JvmName("DateTimeConvertor")
@@ -65,8 +65,8 @@ class DateTimeTypeHandler : BaseTypeHandler<DateTime>() {
override fun setNonNullParameter(
ps: PreparedStatement,
i: Int,
parameter: DateTime, // 移除了 ?,因为这是 non-null 方法
jdbcType: JdbcType
parameter: DateTime,
jdbcType: JdbcType?
) {
// 使用 setObject 允许传入 null,由数据库处理
ps.setObject(i, toLocalDateTime(parameter))
@@ -16,7 +16,7 @@
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile UUIDTypeHandler.kt
* LastUpdate 2025-09-14 18:19:29
* LastUpdate 2025-09-15 13:54:18
* UpdateUser MingLiPro
*/
@file:JvmName("UUIDConvertor")
@@ -112,7 +112,7 @@ class UUIDBinaryTypeHandler : BaseTypeHandler<UUID>() {
* @param jdbcType JDBC类型
*/
override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) {
ps.setBytes(i, uuidToByteArray(parameter))
}
@@ -172,7 +172,7 @@ class UUIDStringTypeHandler : BaseTypeHandler<UUID>() {
* @param jdbcType JDBC类型
*/
override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) {
ps.setString(i, uuidToString(parameter))
}
@@ -234,7 +234,7 @@ class UUIDTypeHandler : BaseTypeHandler<UUID>() {
* @param jdbcType JDBC类型
*/
override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) {
ps.setObject(i, parameter.getUuid())
}
@@ -16,7 +16,7 @@
* ProjectName mingli-utils
* ModuleName mingli-utils.main
* CurrentFile MysqlUUIDBinaryTypeHandler.kt
* LastUpdate 2025-09-14 18:19:29
* LastUpdate 2025-09-15 13:54:29
* UpdateUser MingLiPro
*/
@@ -72,7 +72,7 @@ class MysqlUUIDBinaryTypeHandler : BaseTypeHandler<UUID>() {
ps: PreparedStatement,
i: Int,
parameter: UUID,
jdbcType: JdbcType
jdbcType: JdbcType?
) {
ps.setBytes(i, toByteArray(parameter))
}