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 # ProjectName mingli-utils
# ModuleName mingli-utils # ModuleName mingli-utils
# CurrentFile gradle.properties # CurrentFile gradle.properties
# LastUpdate 2025-09-15 12:01:24 # LastUpdate 2025-09-15 13:54:50
# UpdateUser MingLiPro # UpdateUser MingLiPro
# #
JDKVERSIONS=1.8 JDKVERSIONS=1.8
GROUPSID=com.mingliqiye.utils GROUPSID=com.mingliqiye.utils
ARTIFACTID=mingli-utils ARTIFACTID=mingli-utils
VERSIONS=4.0.2 VERSIONS=4.0.4
@@ -16,24 +16,30 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile ForEach.kt * CurrentFile ForEach.kt
* LastUpdate 2025-09-15 12:01:36 * LastUpdate 2025-09-15 12:44:46
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("ForEach") @file:JvmName("ForEach")
package com.mingliqiye.utils.foreach package com.mingliqiye.utils.foreach
import com.mingliqiye.utils.functions.P1Function import com.mingliqiye.utils.functions.*
import com.mingliqiye.utils.functions.P1RFunction
import com.mingliqiye.utils.functions.P2Function
import com.mingliqiye.utils.functions.P2RFunction
/**
* 对给定的可迭代对象执行指定的操作,同时处理元素值和索引。
* 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。
*
* @param iterable 要遍历的可迭代对象
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param <T> 可迭代对象中元素的类型
*/
fun <T> forEach( fun <T> forEach(
iterable: Iterable<T>, action: P2Function<in T, in Int> iterable: Iterable<T>, action: P2Function<in T, in Int>
) { ) {
when (iterable) { when (iterable) {
is RandomAccess if iterable is MutableList<*> -> { is RandomAccess if iterable is MutableList<*> -> {
// 如果是支持随机访问的可变列表,则使用索引遍历以提高性能
val list = iterable as MutableList<T> val list = iterable as MutableList<T>
for (i in list.indices) { for (i in list.indices) {
action.call(list[i], i) action.call(list[i], i)
@@ -41,6 +47,7 @@ fun <T> forEach(
} }
is MutableList<*> -> { is MutableList<*> -> {
// 对于普通可变列表,使用迭代器进行遍历,并手动维护索引
var index = 0 var index = 0
val it = iterable.iterator() val it = iterable.iterator()
while (it.hasNext()) { while (it.hasNext()) {
@@ -50,6 +57,7 @@ fun <T> forEach(
} }
else -> { else -> {
// 对于其他类型的可迭代对象,使用增强 for 循环并手动维护索引
var index = 0 var index = 0
for (element in iterable) { for (element in iterable) {
action.call(element, index) action.call(element, index)
@@ -66,27 +74,39 @@ fun <T> forEach(
* @param iterable 要遍历的可迭代对象 * @param iterable 要遍历的可迭代对象
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param <T> 可迭代对象中元素的类型 * @param <T> 可迭代对象中元素的类型
**/ */
fun <T> forEach( fun <T> forEach(
iterable: Iterable<T>, action: P1Function<in T> iterable: Iterable<T>, action: P1Function<in T>
) { ) {
if (iterable is RandomAccess) { if (iterable is RandomAccess) {
// 如果是支持随机访问的列表,则使用索引遍历以提高性能
val list = iterable as MutableList<T> val list = iterable as MutableList<T>
for (i in list.indices) { for (i in list.indices) {
action.call(list[i]) action.call(list[i])
} }
} else { } else {
// 否则使用增强 for 循环进行遍历
for (element in iterable) { for (element in iterable) {
action.call(element) 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> iterable: Iterable<T>, action: P2RFunction<in T, in Int, out Boolean>
) { ) {
when (iterable) { when (iterable) {
is RandomAccess if iterable is MutableList<*> -> { is RandomAccess if iterable is MutableList<*> -> {
// 如果是支持随机访问的可变列表,则使用索引遍历以提高性能
val list = iterable as MutableList<T> val list = iterable as MutableList<T>
for (i in list.indices) { for (i in list.indices) {
if (action.call(list[i], i)) return if (action.call(list[i], i)) return
@@ -94,6 +114,7 @@ fun <T> forEach(
} }
is MutableList<*> -> { is MutableList<*> -> {
// 对于普通可变列表,使用迭代器进行遍历,并手动维护索引
var index = 0 var index = 0
val it = iterable.iterator() val it = iterable.iterator()
while (it.hasNext()) { while (it.hasNext()) {
@@ -103,6 +124,7 @@ fun <T> forEach(
} }
else -> { else -> {
// 对于其他类型的可迭代对象,使用增强 for 循环并手动维护索引
var index = 0 var index = 0
for (element in iterable) { for (element in iterable) {
if (action.call(element, index)) return if (action.call(element, index)) return
@@ -114,242 +136,574 @@ fun <T> forEach(
/** /**
* 对给定的可迭代对象执行指定的操作,仅处理元素值。 * 对给定的可迭代对象执行指定的操作,仅处理元素值。
* 如果操作返回 true,则提前终止遍历。
* 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。 * 根据可迭代对象是否实现 RandomAccess 接口选择最优的遍历方式。
* *
* @param iterable 要遍历的可迭代对象 * @param iterable 要遍历的可迭代对象
* @param action 要对每个元素执行的操作,只接收元素值作为参数 * @param action 要对每个元素执行的操作,只接收元素值作为参数,返回 Boolean 表示是否提前终止
* @param <T> 可迭代对象中元素的类型 * @param <T> 可迭代对象中元素的类型
**/ */
fun <T> forEach( fun <T> forEachB(
iterable: Iterable<T>, action: P1RFunction<in T, out Boolean> iterable: Iterable<T>, action: P1RFunction<in T, out Boolean>
) { ) {
if (iterable is RandomAccess) { if (iterable is RandomAccess) {
// 如果是支持随机访问的列表,则使用索引遍历以提高性能
val list = iterable as MutableList<T> val list = iterable as MutableList<T>
for (i in list.indices) { for (i in list.indices) {
if (action.call(list[i])) return if (action.call(list[i])) return
} }
} else { } else {
// 否则使用增强 for 循环进行遍历
for (element in iterable) { for (element in iterable) {
if (action.call(element)) return if (action.call(element)) return
} }
} }
} }
/**
* 对给定的数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
* @param <T> 数组中元素的类型
*/
fun <T> forEach( fun <T> forEach(
array: Array<T>, action: P2Function<in T, in Int> array: Array<T>, action: P2Function<in T, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
* @param <T> 数组中元素的类型
*/
fun <T> forEach( fun <T> forEach(
array: Array<T>, action: P1Function<in T> array: Array<T>, action: P1Function<in T>
) { ) {
forEach(array.toList(), action) 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> 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> array: Array<T>, action: P1RFunction<in T, out Boolean>
) { ) {
forEach(array.toList(), action) forEachB(array.toList(), action)
} }
/**
* 对给定的字节数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的字节数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/
fun forEach( fun forEach(
array: ByteArray, action: P2Function<in Byte, in Int> array: ByteArray, action: P2Function<in Byte, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的字节数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的字节数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
*/
fun forEach( fun forEach(
array: ByteArray, action: P1Function<in Byte> array: ByteArray, action: P1Function<in Byte>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
fun forEach( * 对给定的字节数组执行指定的操作,同时处理元素值和索引。
* 如果操作返回 true,则提前终止遍历。
*
* @param array 要遍历的字节数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数,返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: ByteArray, action: P2RFunction<in Byte, in Int, out Boolean> 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> array: ByteArray, action: P1RFunction<in Byte, out Boolean>
) { ) {
forEach(array.toList(), action) forEachB(array.toList(), action)
} }
/**
* 对给定的字符数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的字符数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/
fun forEach( fun forEach(
array: CharArray, action: P2Function<in Char, in Int> array: CharArray, action: P2Function<in Char, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的字符数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的字符数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
*/
fun forEach( fun forEach(
array: CharArray, action: P1Function<in Char> array: CharArray, action: P1Function<in Char>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
fun forEach( /**
* 对给定的字符数组执行指定的操作,同时处理元素值和索引。
* 如果操作返回 true,则提前终止遍历。
*
* @param array 要遍历的字符数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数,返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: CharArray, action: P2RFunction<in Char, in Int, out Boolean> 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> array: CharArray, action: P1RFunction<in Char, out Boolean>
) { ) {
forEach(array.toList(), action) forEachB(array.toList(), action)
} }
/**
* 对给定的整型数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/
fun forEach( fun forEach(
array: IntArray, action: P2Function<in Int, in Int> array: IntArray, action: P2Function<in Int, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的整型数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的整型数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
*/
fun forEach( fun forEach(
array: IntArray, action: P1Function<in Int> array: IntArray, action: P1Function<in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
fun forEach( /**
* 对给定的整型数组执行指定的操作,同时处理元素值和索引。
* 如果操作返回 true,则提前终止遍历。
*
* @param array 要遍历的整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数,返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: IntArray, action: P2RFunction<in Int, in Int, out Boolean> 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> array: IntArray, action: P1RFunction<in Int, out Boolean>
) { ) {
forEach(array.toList(), action) forEachB(array.toList(), action)
} }
/**
* 对给定的长整型数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的长整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/
fun forEach( fun forEach(
array: LongArray, action: P2Function<in Long, in Int> array: LongArray, action: P2Function<in Long, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的长整型数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的长整型数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
*/
fun forEach( fun forEach(
array: LongArray, action: P1Function<in Long> array: LongArray, action: P1Function<in Long>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
fun forEach( /**
* 对给定的长整型数组执行指定的操作,同时处理元素值和索引。
* 如果操作返回 true,则提前终止遍历。
*
* @param array 要遍历的长整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数,返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: LongArray, action: P2RFunction<in Long, in Int, out Boolean> 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> array: LongArray, action: P1RFunction<in Long, out Boolean>
) { ) {
forEach(array.toList(), action) forEachB(array.toList(), action)
} }
/**
* 对给定的短整型数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的短整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/
fun forEach( fun forEach(
array: ShortArray, action: P2Function<in Short, in Int> array: ShortArray, action: P2Function<in Short, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的短整型数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的短整型数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
*/
fun forEach( fun forEach(
array: ShortArray, action: P1Function<in Short> array: ShortArray, action: P1Function<in Short>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
fun forEach( /**
* 对给定的短整型数组执行指定的操作,同时处理元素值和索引。
* 如果操作返回 true,则提前终止遍历。
*
* @param array 要遍历的短整型数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数,返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: ShortArray, action: P2RFunction<in Short, in Int, out Boolean> 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> array: ShortArray, action: P1RFunction<in Short, out Boolean>
) { ) {
forEach(array.toList(), action) forEachB(array.toList(), action)
} }
/**
* 对给定的浮点数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的浮点数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/
fun forEach( fun forEach(
array: FloatArray, action: P2Function<in Float, in Int> array: FloatArray, action: P2Function<in Float, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的浮点数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的浮点数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
*/
fun forEach( fun forEach(
array: FloatArray, action: P1Function<in Float> array: FloatArray, action: P1Function<in Float>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
fun forEach( /**
* 对给定的浮点数组执行指定的操作,同时处理元素值和索引。
* 如果操作返回 true,则提前终止遍历。
*
* @param array 要遍历的浮点数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数,返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: FloatArray, action: P2RFunction<in Float, in Int, out Boolean> 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> array: FloatArray, action: P1RFunction<in Float, out Boolean>
) { ) {
forEach(array.toList(), action) forEachB(array.toList(), action)
} }
/**
* 对给定的双精度浮点数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/
fun forEach( fun forEach(
array: DoubleArray, action: P2Function<in Double, in Int> array: DoubleArray, action: P2Function<in Double, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的双精度浮点数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
*/
fun forEach( fun forEach(
array: DoubleArray, action: P1Function<in Double> array: DoubleArray, action: P1Function<in Double>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
fun forEach( /**
* 对给定的双精度浮点数组执行指定的操作,同时处理元素值和索引。
* 如果操作返回 true,则提前终止遍历。
*
* @param array 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数,返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: DoubleArray, action: P2RFunction<in Double, in Int, out Boolean> 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> array: DoubleArray, action: P1RFunction<in Double, out Boolean>
) { ) {
forEach(array.toList(), action) forEachB(array.toList(), action)
} }
/**
* 对给定的布尔数组执行指定的操作,同时处理元素值和索引。
*
* @param array 要遍历的布尔数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数
*/
fun forEach( fun forEach(
array: BooleanArray, action: P2Function<in Boolean, in Int> array: BooleanArray, action: P2Function<in Boolean, in Int>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
/**
* 对给定的布尔数组执行指定的操作,仅处理元素值。
*
* @param array 要遍历的布尔数组
* @param action 要对每个元素执行的操作,只接收元素值作为参数
*/
fun forEach( fun forEach(
array: BooleanArray, action: P1Function<in Boolean> array: BooleanArray, action: P1Function<in Boolean>
) { ) {
forEach(array.toList(), action) forEach(array.toList(), action)
} }
fun forEach( /**
* 对给定的布尔数组执行指定的操作,同时处理元素值和索引。
* 如果操作返回 true,则提前终止遍历。
*
* @param array 要遍历的布尔数组
* @param action 要对每个元素执行的操作,接收元素值和索引作为参数,返回 Boolean 表示是否提前终止
*/
fun forEachB(
array: BooleanArray, action: P2RFunction<in Boolean, in Int, out Boolean> 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> 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 * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile DateTimeTypeHandler.kt * CurrentFile DateTimeTypeHandler.kt
* LastUpdate 2025-09-14 18:19:29 * LastUpdate 2025-09-15 13:53:53
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("DateTimeConvertor") @file:JvmName("DateTimeConvertor")
@@ -65,8 +65,8 @@ class DateTimeTypeHandler : BaseTypeHandler<DateTime>() {
override fun setNonNullParameter( override fun setNonNullParameter(
ps: PreparedStatement, ps: PreparedStatement,
i: Int, i: Int,
parameter: DateTime, // 移除了 ?,因为这是 non-null 方法 parameter: DateTime,
jdbcType: JdbcType jdbcType: JdbcType?
) { ) {
// 使用 setObject 允许传入 null,由数据库处理 // 使用 setObject 允许传入 null,由数据库处理
ps.setObject(i, toLocalDateTime(parameter)) ps.setObject(i, toLocalDateTime(parameter))
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile UUIDTypeHandler.kt * CurrentFile UUIDTypeHandler.kt
* LastUpdate 2025-09-14 18:19:29 * LastUpdate 2025-09-15 13:54:18
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@file:JvmName("UUIDConvertor") @file:JvmName("UUIDConvertor")
@@ -112,7 +112,7 @@ class UUIDBinaryTypeHandler : BaseTypeHandler<UUID>() {
* @param jdbcType JDBC类型 * @param jdbcType JDBC类型
*/ */
override fun setNonNullParameter( override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) { ) {
ps.setBytes(i, uuidToByteArray(parameter)) ps.setBytes(i, uuidToByteArray(parameter))
} }
@@ -172,7 +172,7 @@ class UUIDStringTypeHandler : BaseTypeHandler<UUID>() {
* @param jdbcType JDBC类型 * @param jdbcType JDBC类型
*/ */
override fun setNonNullParameter( override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) { ) {
ps.setString(i, uuidToString(parameter)) ps.setString(i, uuidToString(parameter))
} }
@@ -234,7 +234,7 @@ class UUIDTypeHandler : BaseTypeHandler<UUID>() {
* @param jdbcType JDBC类型 * @param jdbcType JDBC类型
*/ */
override fun setNonNullParameter( override fun setNonNullParameter(
ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType ps: PreparedStatement, i: Int, parameter: UUID, jdbcType: JdbcType?
) { ) {
ps.setObject(i, parameter.getUuid()) ps.setObject(i, parameter.getUuid())
} }
@@ -16,7 +16,7 @@
* ProjectName mingli-utils * ProjectName mingli-utils
* ModuleName mingli-utils.main * ModuleName mingli-utils.main
* CurrentFile MysqlUUIDBinaryTypeHandler.kt * CurrentFile MysqlUUIDBinaryTypeHandler.kt
* LastUpdate 2025-09-14 18:19:29 * LastUpdate 2025-09-15 13:54:29
* UpdateUser MingLiPro * UpdateUser MingLiPro
*/ */
@@ -72,7 +72,7 @@ class MysqlUUIDBinaryTypeHandler : BaseTypeHandler<UUID>() {
ps: PreparedStatement, ps: PreparedStatement,
i: Int, i: Int,
parameter: UUID, parameter: UUID,
jdbcType: JdbcType jdbcType: JdbcType?
) { ) {
ps.setBytes(i, toByteArray(parameter)) ps.setBytes(i, toByteArray(parameter))
} }