refactor(utils): 重构工具类并添加新功能

- 重构了 AutoConfiguration 类，更新了组件扫描路径 - 优化了 Collection 类中的 getOrDefault 方法，增加了对非 List 集合的支持- 添加了 DateTime 类的高精度时间处理功能 - 新增了 DateTimeToStringConverter 类，用于将 DateTime 转换为字符串 - 更新了 ForEach 类中的遍历方法，提高了代码可读性和性能
2025-09-11 09:46:03 +08:00 · 2025-09-11 09:46:03 +08:00 · 1a9553b55d
commit 1a9553b55d
parent bbafa86872
22 changed files with 2099 additions and 1718 deletions
--- a/gradle.properties
+++ b/gradle.properties
@ -22,4 +22,4 @@
 JDKVERSIONS=1.8
 GROUPSID=com.mingliqiye.utils
 ARTIFACTID=mingli-utils
-VERSIONS=3.0.4
+VERSIONS=3.0.6
--- a/package.json
+++ b/package.json
@ -4,7 +4,8 @@
 	"scripts": {
 		"build": "gradle build-jar",
 		"buildw": "gradlew build-jar",
-		"format": "prettier --write \"**/*.{js,ts,jsx,tsx,cjs,cts,mjs,mts,vue,astro,json,java}\""
+		"format": "prettier --write \"**/*.{js,ts,jsx,tsx,cjs,cts,mjs,mts,vue,astro,json,java}\"",
+		"f": "prettier --write \"**/*.{js,ts,jsx,tsx,cjs,cts,mjs,mts,vue,astro,json,java}\""
 	},
 	"devDependencies": {
 		"prettier-plugin-java": "^2.7.1",
--- a/src/main/java/com/mingliqiye/utils/Main.java
+++ b/src/main/java/com/mingliqiye/utils/Main.java
@ -22,21 +22,12 @@

 package com.mingliqiye.utils;

-import com.mingliqiye.utils.collection.Lists;
-import com.mingliqiye.utils.collection.Maps;
 import com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration;
-import com.mingliqiye.utils.stream.SuperStream;
 import java.io.IOException;
-import java.util.List;
-import java.util.Map;

 public class Main {

 	public static void main(String[] args) throws IOException {
 		AutoConfiguration.printBanner();
-
-		Map<String, String> map = Maps.of("1", "2", "3", "4");
-
-		SuperStream.of(map).entryToMap();
 	}
 }
--- a/src/main/java/com/mingliqiye/utils/bean/springboot/SpringBeanUtil.java
+++ b/src/main/java/com/mingliqiye/utils/bean/springboot/SpringBeanUtil.java
@ -41,9 +41,6 @@ import org.springframework.stereotype.Component;
@Component
 public class SpringBeanUtil implements ApplicationContextAware {

-	public static final String PACKAGE_NAME =
-		"com.mingliqiye.utils.bean.springboot";
-
 	/**
 	 * 获取applicationContext
 	 */
--- a/src/main/java/com/mingliqiye/utils/collection/Collection.java
+++ b/src/main/java/com/mingliqiye/utils/collection/Collection.java
@ -22,6 +22,7 @@

 package com.mingliqiye.utils.collection;

+import com.mingliqiye.utils.stream.SuperStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@ -127,14 +128,28 @@ public class Collection {
 	 */
 	@Nullable
 	public static <T> T getOrDefault(
-		@NotNull List<T> list,
+		@NotNull java.util.Collection<T> list,
 		int index,
 		@Nullable T defaultValue
 	) {
 		if (index < 0 || index >= list.size()) {
 			return defaultValue;
 		}
-		return list.get(index);
+		return SuperStream.of(list).get(index);
+	}
+
+	/**
+	 * 获取集合中指定索引的元素。
+	 * 如果索引超出范围则返回null。
+	 *
+	 * @param list  集合
+	 * @param index 索引
+	 * @param <T>   元素类型
+	 * @return 指定索引的元素，如果索引超出范围则返回null
+	 */
+	@Nullable
+	public static <T> T get(@NotNull java.util.Collection<T> list, int index) {
+		return getOrDefault(list, index, null);
 	}

 	/**
--- a/src/main/java/com/mingliqiye/utils/collection/ForEach.java
+++ b/src/main/java/com/mingliqiye/utils/collection/ForEach.java
@ -26,7 +26,6 @@ import com.mingliqiye.utils.functions.P1Function;
 import com.mingliqiye.utils.functions.P2Function;
 import com.mingliqiye.utils.functions.P3Function;
 import com.mingliqiye.utils.stream.SuperStream;
-
 import java.util.*;
 import java.util.Collection;
 import java.util.concurrent.ConcurrentMap;
@ -46,431 +45,499 @@ import java.util.function.Function;
 */
 public class ForEach {

-    /**
-     * 对给定的集合执行指定的操作，操作包含元素值和索引。
-     * 根据集合类型选择最优的遍历方式以提高性能。
-     *
-     * @param collection 要遍历的集合，可以是 List 或其他 Collection 实现
-     * @param action     要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param <T>        集合中元素的类型
-     */
-    public static <T> void forEach(Collection<T> collection, P2Function<? super T, Integer> action) {
-        // 参数校验：如果集合或操作为空，则直接返回
-        if (collection == null || action == null) {
-            return;
-        }
+	/**
+	 * 对给定的集合执行指定的操作，操作包含元素值和索引。
+	 * 根据集合类型选择最优的遍历方式以提高性能。
+	 *
+	 * @param collection 要遍历的集合，可以是 List 或其他 Collection 实现
+	 * @param action     要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param <T>        集合中元素的类型
+	 */
+	public static <T> void forEach(
+		Collection<T> collection,
+		P2Function<? super T, Integer> action
+	) {
+		// 参数校验：如果集合或操作为空，则直接返回
+		if (collection == null || action == null) {
+			return;
+		}

-        // 如果集合实现了 RandomAccess 接口（如 ArrayList），使用索引访问优化性能
-        if (collection instanceof RandomAccess && collection instanceof List) {
-            List<T> list = (List<T>) collection;
-            for (int i = 0; i < list.size(); i++) {
-                action.call(list.get(i), i);
-            }
-        }
-        // 如果是普通 List，使用迭代器遍历并手动维护索引
-        else if (collection instanceof List) {
-            int index = 0;
-            Iterator<T> it = collection.iterator();
-            while (it.hasNext()) {
-                action.call(it.next(), index);
-                index++;
-            }
-        }
-        // 其他类型的集合使用增强 for 循环，并手动维护索引
-        else {
-            int index = 0;
-            for (T element : collection) {
-                action.call(element, index);
-                index++;
-            }
-        }
-    }
+		// 如果集合实现了 RandomAccess 接口（如 ArrayList），使用索引访问优化性能
+		if (collection instanceof RandomAccess && collection instanceof List) {
+			List<T> list = (List<T>) collection;
+			for (int i = 0; i < list.size(); i++) {
+				action.call(list.get(i), i);
+			}
+		}
+		// 如果是普通 List，使用迭代器遍历并手动维护索引
+		else if (collection instanceof List) {
+			int index = 0;
+			Iterator<T> it = collection.iterator();
+			while (it.hasNext()) {
+				action.call(it.next(), index);
+				index++;
+			}
+		}
+		// 其他类型的集合使用增强 for 循环，并手动维护索引
+		else {
+			int index = 0;
+			for (T element : collection) {
+				action.call(element, index);
+				index++;
+			}
+		}
+	}

-    /**
-     * 对给定的集合执行指定的操作，仅处理元素值。
-     * 根据集合是否实现 RandomAccess 接口选择最优的遍历方式。
-     *
-     * @param collection 要遍历的集合
-     * @param action     要对每个元素执行的操作，只接收元素值作为参数
-     * @param <T>        集合中元素的类型
-     */
-    public static <T> void forEach(Collection<T> collection, P1Function<? super T> action) {
-        // 参数校验：如果集合或操作为空，则直接返回
-        if (collection == null || action == null) {
-            return;
-        }
+	/**
+	 * 对给定的集合执行指定的操作，仅处理元素值。
+	 * 根据集合是否实现 RandomAccess 接口选择最优的遍历方式。
+	 *
+	 * @param collection 要遍历的集合
+	 * @param action     要对每个元素执行的操作，只接收元素值作为参数
+	 * @param <T>        集合中元素的类型
+	 */
+	public static <T> void forEach(
+		Collection<T> collection,
+		P1Function<? super T> action
+	) {
+		// 参数校验：如果集合或操作为空，则直接返回
+		if (collection == null || action == null) {
+			return;
+		}

-        // 如果集合实现了 RandomAccess 接口，使用索引访问提升性能
-        if (collection instanceof RandomAccess) {
-            List<T> list = (List<T>) collection;
-            for (int i = 0; i < list.size(); i++) {
-                action.call(list.get(i));
-            }
-        }
-        // 否则使用增强 for 循环进行遍历
-        else {
-            for (T element : collection) {
-                action.call(element);
-            }
-        }
-    }
+		// 如果集合实现了 RandomAccess 接口，使用索引访问提升性能
+		if (collection instanceof RandomAccess) {
+			List<T> list = (List<T>) collection;
+			for (int i = 0; i < list.size(); i++) {
+				action.call(list.get(i));
+			}
+		}
+		// 否则使用增强 for 循环进行遍历
+		else {
+			for (T element : collection) {
+				action.call(element);
+			}
+		}
+	}

-    /**
-     * 对给定的映射执行指定的操作，操作包含键、值和索引。
-     * 根据映射类型选择不同的遍历策略。
-     *
-     * @param map    要遍历的映射
-     * @param action 要对每个键值对执行的操作，接收键、值和索引作为参数
-     * @param <K>    映射中键的类型
-     * @param <V>    映射中值的类型
-     */
-    public static <K, V> void forEach(Map<K, V> map, P3Function<? super K, ? super V, Integer> action) {
-        // 参数校验：如果映射或操作为空，则直接返回
-        if (map == null || action == null) {
-            return;
-        }
+	/**
+	 * 对给定的映射执行指定的操作，操作包含键、值和索引。
+	 * 根据映射类型选择不同的遍历策略。
+	 *
+	 * @param map    要遍历的映射
+	 * @param action 要对每个键值对执行的操作，接收键、值和索引作为参数
+	 * @param <K>    映射中键的类型
+	 * @param <V>    映射中值的类型
+	 */
+	public static <K, V> void forEach(
+		Map<K, V> map,
+		P3Function<? super K, ? super V, Integer> action
+	) {
+		// 参数校验：如果映射或操作为空，则直接返回
+		if (map == null || action == null) {
+			return;
+		}

-        // 遍历 TreeMap 的条目集合并传递索引
-        if (map instanceof TreeMap) {
-            int index = 0;
-            for (Map.Entry<K, V> entry : map.entrySet()) {
-                action.call(entry.getKey(), entry.getValue(), index);
-                index++;
-            }
-        }
-        // 遍历 ConcurrentMap 或 LinkedHashMap 的条目集合并传递索引
-        else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
-            int index = 0;
-            for (Map.Entry<K, V> entry : map.entrySet()) {
-                action.call(entry.getKey(), entry.getValue(), index);
-                index++;
-            }
-        }
-        // 遍历其他类型映射的条目集合并传递索引
-        else {
-            int index = 0;
-            for (Map.Entry<K, V> entry : map.entrySet()) {
-                action.call(entry.getKey(), entry.getValue(), index);
-                index++;
-            }
-        }
-    }
+		// 遍历 TreeMap 的条目集合并传递索引
+		if (map instanceof TreeMap) {
+			int index = 0;
+			for (Map.Entry<K, V> entry : map.entrySet()) {
+				action.call(entry.getKey(), entry.getValue(), index);
+				index++;
+			}
+		}
+		// 遍历 ConcurrentMap 或 LinkedHashMap 的条目集合并传递索引
+		else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
+			int index = 0;
+			for (Map.Entry<K, V> entry : map.entrySet()) {
+				action.call(entry.getKey(), entry.getValue(), index);
+				index++;
+			}
+		}
+		// 遍历其他类型映射的条目集合并传递索引
+		else {
+			int index = 0;
+			for (Map.Entry<K, V> entry : map.entrySet()) {
+				action.call(entry.getKey(), entry.getValue(), index);
+				index++;
+			}
+		}
+	}

-    /**
-     * 对给定的映射执行指定的操作，仅处理键和值。
-     * 根据映射类型选择不同的遍历策略。
-     *
-     * @param map    要遍历的映射
-     * @param action 要对每个键值对执行的操作，接收键和值作为参数
-     * @param <K>    映射中键的类型
-     * @param <V>    映射中值的类型
-     */
-    public static <K, V> void forEach(Map<K, V> map, P2Function<? super K, ? super V> action) {
-        // 参数校验：如果映射或操作为空，则直接返回
-        if (map == null || action == null) {
-            return;
-        }
+	/**
+	 * 对给定的映射执行指定的操作，仅处理键和值。
+	 * 根据映射类型选择不同的遍历策略。
+	 *
+	 * @param map    要遍历的映射
+	 * @param action 要对每个键值对执行的操作，接收键和值作为参数
+	 * @param <K>    映射中键的类型
+	 * @param <V>    映射中值的类型
+	 */
+	public static <K, V> void forEach(
+		Map<K, V> map,
+		P2Function<? super K, ? super V> action
+	) {
+		// 参数校验：如果映射或操作为空，则直接返回
+		if (map == null || action == null) {
+			return;
+		}

-        // 遍历 TreeMap 的条目集合
-        if (map instanceof TreeMap) {
-            for (Map.Entry<K, V> entry : map.entrySet()) {
-                action.call(entry.getKey(), entry.getValue());
-            }
-        }
-        // 如果是 ConcurrentMap 或 LinkedHashMap，使用其内置的 forEach 方法
-        else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
-            forEach(map.entrySet(), (i) -> action.call(i.getKey(), i.getValue()));
-        }
-        // 遍历其他类型映射的条目集合
-        else {
-            for (Map.Entry<K, V> entry : map.entrySet()) {
-                action.call(entry.getKey(), entry.getValue());
-            }
-        }
-    }
+		// 遍历 TreeMap 的条目集合
+		if (map instanceof TreeMap) {
+			for (Map.Entry<K, V> entry : map.entrySet()) {
+				action.call(entry.getKey(), entry.getValue());
+			}
+		}
+		// 如果是 ConcurrentMap 或 LinkedHashMap，使用其内置的 forEach 方法
+		else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
+			forEach(map.entrySet(), i -> action.call(i.getKey(), i.getValue()));
+		}
+		// 遍历其他类型映射的条目集合
+		else {
+			for (Map.Entry<K, V> entry : map.entrySet()) {
+				action.call(entry.getKey(), entry.getValue());
+			}
+		}
+	}

-    /**
-     * 对可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的可变参数数组
-     * @param <T>     数组中元素的类型
-     */
-    public static <T> void forEach(P2Function<? super T, Integer> action, T... objects) {
-        forEach(Lists.newArrayList(objects), action);
-    }
+	/**
+	 * 对可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的可变参数数组
+	 * @param <T>     数组中元素的类型
+	 */
+	public static <T> void forEach(
+		P2Function<? super T, Integer> action,
+		T... objects
+	) {
+		forEach(Lists.newArrayList(objects), action);
+	}

-    /**
-     * 对数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param <T>     数组中元素的类型
-     */
-    public static <T> void forEach(T[] objects, P2Function<? super T, Integer> action) {
-        forEach(action, objects);
-    }
+	/**
+	 * 对数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param <T>     数组中元素的类型
+	 */
+	public static <T> void forEach(
+		T[] objects,
+		P2Function<? super T, Integer> action
+	) {
+		forEach(action, objects);
+	}

-    /**
-     * 对数组执行指定的操作，仅处理元素值
-     *
-     * @param objects 要遍历的数组
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param <T>     数组中元素的类型
-     */
-    public static <T> void forEach(T[] objects, P1Function<? super T> action) {
-        forEach(action, objects);
-    }
+	/**
+	 * 对数组执行指定的操作，仅处理元素值
+	 *
+	 * @param objects 要遍历的数组
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param <T>     数组中元素的类型
+	 */
+	public static <T> void forEach(T[] objects, P1Function<? super T> action) {
+		forEach(action, objects);
+	}

-    /**
-     * 对可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的可变参数数组
-     * @param <T>     数组中元素的类型
-     */
-    public static <T> void forEach(P1Function<? super T> action, T... objects) {
-        forEach(Lists.toList(objects), (t, i) -> action.call(t));
-    }
+	/**
+	 * 对可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的可变参数数组
+	 * @param <T>     数组中元素的类型
+	 */
+	public static <T> void forEach(P1Function<? super T> action, T... objects) {
+		forEach(Lists.toList(objects), (t, i) -> action.call(t));
+	}

-    /**
-     * 对整型数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的整型数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     */
-    public static void forEach(int[] objects, P2Function<Integer, Integer> action) {
-        forEach(action, objects);
-    }
+	/**
+	 * 对整型数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的整型数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 */
+	public static void forEach(
+		int[] objects,
+		P2Function<Integer, Integer> action
+	) {
+		forEach(action, objects);
+	}

-    /**
-     * 对整型可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的整型可变参数数组
-     */
-    private static void forEach(P2Function<Integer, Integer> action, int... objects) {
-        forEach(objects, action);
-    }
+	/**
+	 * 对整型可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的整型可变参数数组
+	 */
+	private static void forEach(
+		P2Function<Integer, Integer> action,
+		int... objects
+	) {
+		forEach(objects, action);
+	}

-    /**
-     * 对整型可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的整型可变参数数组
-     */
-    private static void forEach(P1Function<Integer> action, int... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对整型可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的整型可变参数数组
+	 */
+	private static void forEach(P1Function<Integer> action, int... objects) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对字节数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的字节数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     */
-    public static void forEach(byte[] objects, P2Function<Byte, Integer> action) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对字节数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的字节数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 */
+	public static void forEach(
+		byte[] objects,
+		P2Function<Byte, Integer> action
+	) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对字节可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的字节可变参数数组
-     */
-    private static void forEach(P2Function<Byte, Integer> action, byte... objects) {
-        forEach(objects, action);
-    }
+	/**
+	 * 对字节可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的字节可变参数数组
+	 */
+	private static void forEach(
+		P2Function<Byte, Integer> action,
+		byte... objects
+	) {
+		forEach(objects, action);
+	}

-    /**
-     * 对字节可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的字节可变参数数组
-     */
-    private static void forEach(P1Function<Byte> action, byte... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对字节可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的字节可变参数数组
+	 */
+	private static void forEach(P1Function<Byte> action, byte... objects) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对短整型数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的短整型数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     */
-    public static void forEach(short[] objects, P2Function<Short, Integer> action) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对短整型数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的短整型数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 */
+	public static void forEach(
+		short[] objects,
+		P2Function<Short, Integer> action
+	) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对短整型可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的短整型可变参数数组
-     */
-    private static void forEach(P2Function<Short, Integer> action, short... objects) {
-        forEach(objects, action);
-    }
+	/**
+	 * 对短整型可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的短整型可变参数数组
+	 */
+	private static void forEach(
+		P2Function<Short, Integer> action,
+		short... objects
+	) {
+		forEach(objects, action);
+	}

-    /**
-     * 对短整型可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的短整型可变参数数组
-     */
-    private static void forEach(P1Function<Short> action, short... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对短整型可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的短整型可变参数数组
+	 */
+	private static void forEach(P1Function<Short> action, short... objects) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对长整型数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的长整型数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     */
-    public static void forEach(long[] objects, P2Function<Long, Integer> action) {
-        forEach(action, objects);
-    }
+	/**
+	 * 对长整型数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的长整型数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 */
+	public static void forEach(
+		long[] objects,
+		P2Function<Long, Integer> action
+	) {
+		forEach(action, objects);
+	}

-    /**
-     * 对长整型可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的长整型可变参数数组
-     */
-    private static void forEach(P2Function<Long, Integer> action, long... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对长整型可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的长整型可变参数数组
+	 */
+	private static void forEach(
+		P2Function<Long, Integer> action,
+		long... objects
+	) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对长整型可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的长整型可变参数数组
-     */
-    private static void forEach(P1Function<Long> action, long... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对长整型可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的长整型可变参数数组
+	 */
+	private static void forEach(P1Function<Long> action, long... objects) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对浮点数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的浮点数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     */
-    public static void forEach(float[] objects, P2Function<Float, Integer> action) {
-        forEach(action, objects);
-    }
+	/**
+	 * 对浮点数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的浮点数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 */
+	public static void forEach(
+		float[] objects,
+		P2Function<Float, Integer> action
+	) {
+		forEach(action, objects);
+	}

-    /**
-     * 对浮点可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的浮点可变参数数组
-     */
-    private static void forEach(P2Function<Float, Integer> action, float... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对浮点可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的浮点可变参数数组
+	 */
+	private static void forEach(
+		P2Function<Float, Integer> action,
+		float... objects
+	) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对浮点可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的浮点可变参数数组
-     */
-    private static void forEach(P1Function<Float> action, float... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对浮点可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的浮点可变参数数组
+	 */
+	private static void forEach(P1Function<Float> action, float... objects) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对双精度浮点数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的双精度浮点数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     */
-    public static void forEach(double[] objects, P2Function<Double, Integer> action) {
-        forEach(action, objects);
-    }
+	/**
+	 * 对双精度浮点数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的双精度浮点数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 */
+	public static void forEach(
+		double[] objects,
+		P2Function<Double, Integer> action
+	) {
+		forEach(action, objects);
+	}

-    /**
-     * 对双精度浮点可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的双精度浮点可变参数数组
-     */
-    private static void forEach(P2Function<Double, Integer> action, double... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对双精度浮点可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的双精度浮点可变参数数组
+	 */
+	private static void forEach(
+		P2Function<Double, Integer> action,
+		double... objects
+	) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对双精度浮点可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的双精度浮点可变参数数组
-     */
-    private static void forEach(P1Function<Double> action, double... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对双精度浮点可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的双精度浮点可变参数数组
+	 */
+	private static void forEach(P1Function<Double> action, double... objects) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对字符数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的字符数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     */
-    public static void forEach(char[] objects, P2Function<Character, Integer> action) {
-        forEach(action, objects);
-    }
+	/**
+	 * 对字符数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的字符数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 */
+	public static void forEach(
+		char[] objects,
+		P2Function<Character, Integer> action
+	) {
+		forEach(action, objects);
+	}

-    /**
-     * 对字符可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的字符可变参数数组
-     */
-    private static void forEach(P2Function<Character, Integer> action, char... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对字符可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的字符可变参数数组
+	 */
+	private static void forEach(
+		P2Function<Character, Integer> action,
+		char... objects
+	) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对字符可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的字符可变参数数组
-     */
-    private static void forEach(P1Function<Character> action, char... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对字符可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的字符可变参数数组
+	 */
+	private static void forEach(P1Function<Character> action, char... objects) {
+		forEach(Lists.toList(objects), action);
+	}

-    /**
-     * 对布尔数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param objects 要遍历的布尔数组
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     */
-    public static void forEach(boolean[] objects, P2Function<Character, Integer> action) {
-        forEach(objects, action);
-    }
+	/**
+	 * 对布尔数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param objects 要遍历的布尔数组
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 */
+	public static void forEach(
+		boolean[] objects,
+		P2Function<Character, Integer> action
+	) {
+		forEach(objects, action);
+	}

-    /**
-     * 对布尔可变参数数组执行指定的操作，操作包含元素值和索引
-     *
-     * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
-     * @param objects 要遍历的布尔可变参数数组
-     */
-    private static void forEach(P2Function<Boolean, Integer> action, boolean... objects) {
-        forEach(Lists.toList(objects), action);
-    }
-
-    /**
-     * 对布尔可变参数数组执行指定的操作，仅处理元素值
-     *
-     * @param action  要对每个元素执行的操作，只接收元素值作为参数
-     * @param objects 要遍历的布尔可变参数数组
-     */
-    private static void forEach(P1Function<Boolean> action, boolean... objects) {
-        forEach(Lists.toList(objects), action);
-    }
+	/**
+	 * 对布尔可变参数数组执行指定的操作，操作包含元素值和索引
+	 *
+	 * @param action  要对每个元素执行的操作，接收元素值和索引作为参数
+	 * @param objects 要遍历的布尔可变参数数组
+	 */
+	private static void forEach(
+		P2Function<Boolean, Integer> action,
+		boolean... objects
+	) {
+		forEach(Lists.toList(objects), action);
+	}

+	/**
+	 * 对布尔可变参数数组执行指定的操作，仅处理元素值
+	 *
+	 * @param action  要对每个元素执行的操作，只接收元素值作为参数
+	 * @param objects 要遍历的布尔可变参数数组
+	 */
+	private static void forEach(
+		P1Function<Boolean> action,
+		boolean... objects
+	) {
+		forEach(Lists.toList(objects), action);
+	}
 }
--- a/src/main/java/com/mingliqiye/utils/collection/ForEachBreaked.java
+++ b/src/main/java/com/mingliqiye/utils/collection/ForEachBreaked.java
--- a/src/main/java/com/mingliqiye/utils/collection/Lists.java
+++ b/src/main/java/com/mingliqiye/utils/collection/Lists.java
@ -22,7 +22,14 @@

 package com.mingliqiye.utils.collection;

+import static com.mingliqiye.utils.collection.Collection.findFirst;
+
+import com.github.f4b6a3.uuid.util.internal.RandomUtil;
+import com.mingliqiye.utils.random.RandomInt;
 import java.util.*;
+import java.util.Collection;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@ -299,6 +306,13 @@ public class Lists {
 		return ts == null ? null : new ArrayList<>(Arrays.asList(ts));
 	}

+	@NotNull
+	public static <T> List<T> toList(Stream<T> ts) {
+		return ts == null
+			? newArrayList()
+			: new ArrayList<>(ts.collect(Collectors.toList()));
+	}
+
 	/**
 	 * 将int数组转换为Integer列表
 	 *
@ -442,4 +456,20 @@ public class Lists {
 		}
 		return list;
 	}
+
+	public <T> T getFirst(Collection<T> collectors) {
+		return com.mingliqiye.utils.collection.Collection.getFirst(collectors);
+	}
+
+	public <T> T getLast(Collection<T> collectors) {
+		return com.mingliqiye.utils.collection.Collection.getFirst(collectors);
+	}
+
+	public <T> T getAny(Collection<T> collectors) {
+		return com.mingliqiye.utils.collection.Collection.getOrDefault(
+			collectors,
+			RandomInt.randomInt(0, collectors.size()),
+			null
+		);
+	}
 }
--- a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java
+++ b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java
@ -42,7 +42,12 @@ import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(AutoConfiguration.class)
-@ComponentScan({ SpringBeanUtil.PACKAGE_NAME })
+@ComponentScan(
+	{
+		"com.mingliqiye.utils.bean.springboot",
+		"com.mingliqiye.utils.springboot.autoconfigure.converters",
+	}
+)
 public class AutoConfiguration {

 	private static final String banner =
--- a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/DateTimeToStringConverter.java
+++ b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/DateTimeToStringConverter.java
@ -0,0 +1,25 @@
+package com.mingliqiye.utils.springboot.autoconfigure.converters;
+
+import static com.mingliqiye.utils.time.Formatter.STANDARD_DATETIME;
+
+import com.mingliqiye.utils.time.DateTime;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+/**
+ * spring boot DateTime到字符串转换器
+ *
+ * @author MingliPro
+ * @see DateTime
+ *
+ *
+ */
+@Component
+public class DateTimeToStringConverter implements Converter<DateTime, String> {
+
+	@Override
+	public String convert(@NotNull DateTime source) {
+		return source.format(STANDARD_DATETIME);
+	}
+}
--- a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToDateTimeConverter.java
+++ b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToDateTimeConverter.java
@ -0,0 +1,25 @@
+package com.mingliqiye.utils.springboot.autoconfigure.converters;
+
+import static com.mingliqiye.utils.time.Formatter.STANDARD_DATETIME_MILLISECOUND7;
+
+import com.mingliqiye.utils.time.DateTime;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+/**
+ * spring boot 字符串到DateTime转换器
+ *
+ * @author MingliPro
+ * @see DateTime
+ *
+ *
+ */
+@Component
+public class StringToDateTimeConverter implements Converter<String, DateTime> {
+
+	@Override
+	public DateTime convert(@NotNull String source) {
+		return DateTime.parse(source, STANDARD_DATETIME_MILLISECOUND7, true);
+	}
+}
--- a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToUUIDConverter.java
+++ b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToUUIDConverter.java
@ -0,0 +1,20 @@
+package com.mingliqiye.utils.springboot.autoconfigure.converters;
+
+import com.mingliqiye.utils.uuid.UUID;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+/**
+ * spring boot 字符串到UUID转换器
+ * @see UUID
+ * @author MingliPro
+ */
+@Component
+public class StringToUUIDConverter implements Converter<String, UUID> {
+
+	@Override
+	public UUID convert(@NotNull String source) {
+		return UUID.of(source);
+	}
+}
--- a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/UUIDToStringConverter.java
+++ b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/UUIDToStringConverter.java
@ -0,0 +1,20 @@
+package com.mingliqiye.utils.springboot.autoconfigure.converters;
+
+import com.mingliqiye.utils.uuid.UUID;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+/**
+ * spring boot UUID到字符串转换器
+ * @see UUID
+ * @author MingliPro
+ */
+@Component
+public class UUIDToStringConverter implements Converter<UUID, String> {
+
+	@Override
+	public String convert(@NotNull UUID source) {
+		return source.toUUIDString();
+	}
+}
--- a/src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java
+++ b/src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java
@ -56,6 +56,7 @@ public class InputStreamUtils {
 	/**
 	 * 将输入流读取为字符串<br>
 	 * 请在外部自行关闭输入流对象 避免资源泄露
+	 *
 	 * @param inputStream 输入流对象，用于读取数据
 	 * @return 输入流对应的字符串内容
 	 * @throws IOException 当读取输入流时发生IO异常
--- a/src/main/java/com/mingliqiye/utils/stream/SuperStream.java
+++ b/src/main/java/com/mingliqiye/utils/stream/SuperStream.java
--- a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java
+++ b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java
@ -0,0 +1,9 @@
+package com.mingliqiye.utils.stream.interfaces;
+
+public interface GetIdable<T> extends Getable<T> {
+	T getId();
+
+	default T get() {
+		return getId();
+	}
+}
--- a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java
+++ b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java
@ -0,0 +1,9 @@
+package com.mingliqiye.utils.stream.interfaces;
+
+public interface GetKeyable<T> {
+	T getKey();
+
+	default T get() {
+		return getKey();
+	}
+}
--- a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java
+++ b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java
@ -0,0 +1,9 @@
+package com.mingliqiye.utils.stream.interfaces;
+
+public interface GetNameable<T> extends Getable<T> {
+	T getName();
+
+	default T get() {
+		return getName();
+	}
+}
--- a/src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java
+++ b/src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java
@ -0,0 +1,5 @@
+package com.mingliqiye.utils.stream.interfaces;
+
+public interface Getable<T> {
+	T get();
+}
--- a/src/main/java/com/mingliqiye/utils/string/StringUtil.java
+++ b/src/main/java/com/mingliqiye/utils/string/StringUtil.java
@ -22,8 +22,8 @@

 package com.mingliqiye.utils.string;

-import com.mingliqiye.utils.functions.P1RFunction;
 import com.mingliqiye.utils.collection.Lists;
+import com.mingliqiye.utils.functions.P1RFunction;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
--- a/src/main/java/com/mingliqiye/utils/time/DateTime.java
+++ b/src/main/java/com/mingliqiye/utils/time/DateTime.java
@ -23,6 +23,7 @@
 package com.mingliqiye.utils.time;

 import com.mingliqiye.utils.jna.time.WinKernel32;
+import com.mingliqiye.utils.system.SystemUtil;
 import java.io.Serializable;
 import java.time.Instant;
 import java.time.LocalDateTime;
@ -36,8 +37,10 @@ import lombok.var;
 import org.jetbrains.annotations.NotNull;

 /**
- * 时间工具类，用于处理日期时间的转换、格式化等操作。
+ * 时间类，用于处理日期时间的转换、格式化等操作。
 * 提供了多种静态方法来创建 DateTime 实例，并支持与 Date、LocalDateTime 等类型的互转。
+ *<br>
+ * windows java 1.8 及以下 使用windows Api 获取高精度时间
 *
 * @author MingLiPro
 * @see java.time
@ -51,13 +54,12 @@ import org.jetbrains.annotations.NotNull;
@Setter
 public final class DateTime implements Serializable {

-	private static final String version = System.getProperty("java.version");
 	private static final WinKernel32 WIN_KERNEL_32;
 	private static final long FILETIME_EPOCH_OFFSET = -116444736000000000L;
 	private static final long NANOS_PER_100NS = 100;

 	static {
-		if (version.startsWith("1.8")) {
+		if (!SystemUtil.isJdk8Plus() && SystemUtil.isWindows()) {
 			WIN_KERNEL_32 = WinKernel32.load();
 		} else {
 			WIN_KERNEL_32 = null;
@ -118,10 +120,6 @@ public final class DateTime implements Serializable {
 		return new DateTime();
 	}

-	public static void main(String[] args) {
-		System.out.println(DateTime.now());
-	}
-
 	/**
 	 * 将 Date 对象转换为 DateTime 实例。
 	 *
--- a/src/main/java/com/mingliqiye/utils/time/serialization/Jackson.java
+++ b/src/main/java/com/mingliqiye/utils/time/serialization/Jackson.java
@ -48,7 +48,7 @@ public class Jackson {
 	public static void addSerializers(ObjectMapper objectMapper) {
 		// 创建SimpleModule并添加DateTime类型的序列化器和反序列化器
 		SimpleModule module = new SimpleModule()
-			.addSerializer(DateTime.class, new DateTimeJsonSerializerM7())
+			.addSerializer(DateTime.class, new DateTimeJsonSerializer())
 			.addDeserializer(DateTime.class, new DateTimeJsonDeserializerM7());
 		objectMapper.registerModule(module);
 	}