diff --git a/gradle.properties b/gradle.properties index 212e209..bdc0fc2 100644 --- 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 diff --git a/package.json b/package.json index 1a80db0..e14f42e 100644 --- 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", diff --git a/src/main/java/com/mingliqiye/utils/Main.java b/src/main/java/com/mingliqiye/utils/Main.java index 6af2552..97a3fd9 100644 --- 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 map = Maps.of("1", "2", "3", "4"); - - SuperStream.of(map).entryToMap(); } } diff --git a/src/main/java/com/mingliqiye/utils/bean/springboot/SpringBeanUtil.java b/src/main/java/com/mingliqiye/utils/bean/springboot/SpringBeanUtil.java index 9aa7c0b..d8693b1 100644 --- 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 */ diff --git a/src/main/java/com/mingliqiye/utils/collection/Collection.java b/src/main/java/com/mingliqiye/utils/collection/Collection.java index 5aa50d1..b9fa0be 100644 --- 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 getOrDefault( - @NotNull List list, + @NotNull java.util.Collection 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 元素类型 + * @return 指定索引的元素，如果索引超出范围则返回null + */ + @Nullable + public static T get(@NotNull java.util.Collection list, int index) { + return getOrDefault(list, index, null); } /** diff --git a/src/main/java/com/mingliqiye/utils/collection/ForEach.java b/src/main/java/com/mingliqiye/utils/collection/ForEach.java index 5994154..b9a5a40 100644 --- 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 集合中元素的类型 - */ - public static void forEach(Collection collection, P2Function action) { - // 参数校验：如果集合或操作为空，则直接返回 - if (collection == null || action == null) { - return; - } + /** + * 对给定的集合执行指定的操作，操作包含元素值和索引。 + * 根据集合类型选择最优的遍历方式以提高性能。 + * + * @param collection 要遍历的集合，可以是 List 或其他 Collection 实现 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param 集合中元素的类型 + */ + public static void forEach( + Collection collection, + P2Function action + ) { + // 参数校验：如果集合或操作为空，则直接返回 + if (collection == null || action == null) { + return; + } - // 如果集合实现了 RandomAccess 接口（如 ArrayList），使用索引访问优化性能 - if (collection instanceof RandomAccess && collection instanceof List) { - List list = (List) 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 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 list = (List) 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 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 集合中元素的类型 - */ - public static void forEach(Collection collection, P1Function action) { - // 参数校验：如果集合或操作为空，则直接返回 - if (collection == null || action == null) { - return; - } + /** + * 对给定的集合执行指定的操作，仅处理元素值。 + * 根据集合是否实现 RandomAccess 接口选择最优的遍历方式。 + * + * @param collection 要遍历的集合 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param 集合中元素的类型 + */ + public static void forEach( + Collection collection, + P1Function action + ) { + // 参数校验：如果集合或操作为空，则直接返回 + if (collection == null || action == null) { + return; + } - // 如果集合实现了 RandomAccess 接口，使用索引访问提升性能 - if (collection instanceof RandomAccess) { - List list = (List) 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 list = (List) 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 映射中键的类型 - * @param 映射中值的类型 - */ - public static void forEach(Map map, P3Function action) { - // 参数校验：如果映射或操作为空，则直接返回 - if (map == null || action == null) { - return; - } + /** + * 对给定的映射执行指定的操作，操作包含键、值和索引。 + * 根据映射类型选择不同的遍历策略。 + * + * @param map 要遍历的映射 + * @param action 要对每个键值对执行的操作，接收键、值和索引作为参数 + * @param 映射中键的类型 + * @param 映射中值的类型 + */ + public static void forEach( + Map map, + P3Function action + ) { + // 参数校验：如果映射或操作为空，则直接返回 + if (map == null || action == null) { + return; + } - // 遍历 TreeMap 的条目集合并传递索引 - if (map instanceof TreeMap) { - int index = 0; - for (Map.Entry 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 entry : map.entrySet()) { - action.call(entry.getKey(), entry.getValue(), index); - index++; - } - } - // 遍历其他类型映射的条目集合并传递索引 - else { - int index = 0; - for (Map.Entry entry : map.entrySet()) { - action.call(entry.getKey(), entry.getValue(), index); - index++; - } - } - } + // 遍历 TreeMap 的条目集合并传递索引 + if (map instanceof TreeMap) { + int index = 0; + for (Map.Entry 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 entry : map.entrySet()) { + action.call(entry.getKey(), entry.getValue(), index); + index++; + } + } + // 遍历其他类型映射的条目集合并传递索引 + else { + int index = 0; + for (Map.Entry entry : map.entrySet()) { + action.call(entry.getKey(), entry.getValue(), index); + index++; + } + } + } - /** - * 对给定的映射执行指定的操作，仅处理键和值。 - * 根据映射类型选择不同的遍历策略。 - * - * @param map 要遍历的映射 - * @param action 要对每个键值对执行的操作，接收键和值作为参数 - * @param 映射中键的类型 - * @param 映射中值的类型 - */ - public static void forEach(Map map, P2Function action) { - // 参数校验：如果映射或操作为空，则直接返回 - if (map == null || action == null) { - return; - } + /** + * 对给定的映射执行指定的操作，仅处理键和值。 + * 根据映射类型选择不同的遍历策略。 + * + * @param map 要遍历的映射 + * @param action 要对每个键值对执行的操作，接收键和值作为参数 + * @param 映射中键的类型 + * @param 映射中值的类型 + */ + public static void forEach( + Map map, + P2Function action + ) { + // 参数校验：如果映射或操作为空，则直接返回 + if (map == null || action == null) { + return; + } - // 遍历 TreeMap 的条目集合 - if (map instanceof TreeMap) { - for (Map.Entry 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 entry : map.entrySet()) { - action.call(entry.getKey(), entry.getValue()); - } - } - } + // 遍历 TreeMap 的条目集合 + if (map instanceof TreeMap) { + for (Map.Entry 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 entry : map.entrySet()) { + action.call(entry.getKey(), entry.getValue()); + } + } + } - /** - * 对可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的可变参数数组 - * @param 数组中元素的类型 - */ - public static void forEach(P2Function action, T... objects) { - forEach(Lists.newArrayList(objects), action); - } + /** + * 对可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的可变参数数组 + * @param 数组中元素的类型 + */ + public static void forEach( + P2Function action, + T... objects + ) { + forEach(Lists.newArrayList(objects), action); + } - /** - * 对数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param 数组中元素的类型 - */ - public static void forEach(T[] objects, P2Function action) { - forEach(action, objects); - } + /** + * 对数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param 数组中元素的类型 + */ + public static void forEach( + T[] objects, + P2Function action + ) { + forEach(action, objects); + } - /** - * 对数组执行指定的操作，仅处理元素值 - * - * @param objects 要遍历的数组 - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param 数组中元素的类型 - */ - public static void forEach(T[] objects, P1Function action) { - forEach(action, objects); - } + /** + * 对数组执行指定的操作，仅处理元素值 + * + * @param objects 要遍历的数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param 数组中元素的类型 + */ + public static void forEach(T[] objects, P1Function action) { + forEach(action, objects); + } - /** - * 对可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的可变参数数组 - * @param 数组中元素的类型 - */ - public static void forEach(P1Function action, T... objects) { - forEach(Lists.toList(objects), (t, i) -> action.call(t)); - } + /** + * 对可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的可变参数数组 + * @param 数组中元素的类型 + */ + public static void forEach(P1Function action, T... objects) { + forEach(Lists.toList(objects), (t, i) -> action.call(t)); + } - /** - * 对整型数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的整型数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - */ - public static void forEach(int[] objects, P2Function action) { - forEach(action, objects); - } + /** + * 对整型数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ + public static void forEach( + int[] objects, + P2Function action + ) { + forEach(action, objects); + } - /** - * 对整型可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的整型可变参数数组 - */ - private static void forEach(P2Function action, int... objects) { - forEach(objects, action); - } + /** + * 对整型可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的整型可变参数数组 + */ + private static void forEach( + P2Function action, + int... objects + ) { + forEach(objects, action); + } - /** - * 对整型可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的整型可变参数数组 - */ - private static void forEach(P1Function action, int... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对整型可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的整型可变参数数组 + */ + private static void forEach(P1Function action, int... objects) { + forEach(Lists.toList(objects), action); + } - /** - * 对字节数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的字节数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - */ - public static void forEach(byte[] objects, P2Function action) { - forEach(Lists.toList(objects), action); - } + /** + * 对字节数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的字节数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ + public static void forEach( + byte[] objects, + P2Function action + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对字节可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的字节可变参数数组 - */ - private static void forEach(P2Function action, byte... objects) { - forEach(objects, action); - } + /** + * 对字节可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的字节可变参数数组 + */ + private static void forEach( + P2Function action, + byte... objects + ) { + forEach(objects, action); + } - /** - * 对字节可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的字节可变参数数组 - */ - private static void forEach(P1Function action, byte... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对字节可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的字节可变参数数组 + */ + private static void forEach(P1Function action, byte... objects) { + forEach(Lists.toList(objects), action); + } - /** - * 对短整型数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的短整型数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - */ - public static void forEach(short[] objects, P2Function action) { - forEach(Lists.toList(objects), action); - } + /** + * 对短整型数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的短整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ + public static void forEach( + short[] objects, + P2Function action + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对短整型可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的短整型可变参数数组 - */ - private static void forEach(P2Function action, short... objects) { - forEach(objects, action); - } + /** + * 对短整型可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的短整型可变参数数组 + */ + private static void forEach( + P2Function action, + short... objects + ) { + forEach(objects, action); + } - /** - * 对短整型可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的短整型可变参数数组 - */ - private static void forEach(P1Function action, short... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对短整型可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的短整型可变参数数组 + */ + private static void forEach(P1Function action, short... objects) { + forEach(Lists.toList(objects), action); + } - /** - * 对长整型数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的长整型数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - */ - public static void forEach(long[] objects, P2Function action) { - forEach(action, objects); - } + /** + * 对长整型数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的长整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ + public static void forEach( + long[] objects, + P2Function action + ) { + forEach(action, objects); + } - /** - * 对长整型可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的长整型可变参数数组 - */ - private static void forEach(P2Function action, long... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对长整型可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的长整型可变参数数组 + */ + private static void forEach( + P2Function action, + long... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对长整型可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的长整型可变参数数组 - */ - private static void forEach(P1Function action, long... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对长整型可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的长整型可变参数数组 + */ + private static void forEach(P1Function action, long... objects) { + forEach(Lists.toList(objects), action); + } - /** - * 对浮点数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的浮点数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - */ - public static void forEach(float[] objects, P2Function action) { - forEach(action, objects); - } + /** + * 对浮点数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的浮点数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ + public static void forEach( + float[] objects, + P2Function action + ) { + forEach(action, objects); + } - /** - * 对浮点可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的浮点可变参数数组 - */ - private static void forEach(P2Function action, float... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对浮点可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的浮点可变参数数组 + */ + private static void forEach( + P2Function action, + float... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对浮点可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的浮点可变参数数组 - */ - private static void forEach(P1Function action, float... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对浮点可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的浮点可变参数数组 + */ + private static void forEach(P1Function action, float... objects) { + forEach(Lists.toList(objects), action); + } - /** - * 对双精度浮点数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的双精度浮点数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - */ - public static void forEach(double[] objects, P2Function action) { - forEach(action, objects); - } + /** + * 对双精度浮点数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的双精度浮点数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ + public static void forEach( + double[] objects, + P2Function action + ) { + forEach(action, objects); + } - /** - * 对双精度浮点可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的双精度浮点可变参数数组 - */ - private static void forEach(P2Function action, double... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对双精度浮点可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的双精度浮点可变参数数组 + */ + private static void forEach( + P2Function action, + double... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对双精度浮点可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的双精度浮点可变参数数组 - */ - private static void forEach(P1Function action, double... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对双精度浮点可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的双精度浮点可变参数数组 + */ + private static void forEach(P1Function action, double... objects) { + forEach(Lists.toList(objects), action); + } - /** - * 对字符数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的字符数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - */ - public static void forEach(char[] objects, P2Function action) { - forEach(action, objects); - } + /** + * 对字符数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的字符数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ + public static void forEach( + char[] objects, + P2Function action + ) { + forEach(action, objects); + } - /** - * 对字符可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的字符可变参数数组 - */ - private static void forEach(P2Function action, char... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对字符可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的字符可变参数数组 + */ + private static void forEach( + P2Function action, + char... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对字符可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的字符可变参数数组 - */ - private static void forEach(P1Function action, char... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对字符可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的字符可变参数数组 + */ + private static void forEach(P1Function action, char... objects) { + forEach(Lists.toList(objects), action); + } - /** - * 对布尔数组执行指定的操作，操作包含元素值和索引 - * - * @param objects 要遍历的布尔数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - */ - public static void forEach(boolean[] objects, P2Function action) { - forEach(objects, action); - } + /** + * 对布尔数组执行指定的操作，操作包含元素值和索引 + * + * @param objects 要遍历的布尔数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + */ + public static void forEach( + boolean[] objects, + P2Function action + ) { + forEach(objects, action); + } - /** - * 对布尔可变参数数组执行指定的操作，操作包含元素值和索引 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 - * @param objects 要遍历的布尔可变参数数组 - */ - private static void forEach(P2Function action, boolean... objects) { - forEach(Lists.toList(objects), action); - } - - /** - * 对布尔可变参数数组执行指定的操作，仅处理元素值 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数 - * @param objects 要遍历的布尔可变参数数组 - */ - private static void forEach(P1Function action, boolean... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对布尔可变参数数组执行指定的操作，操作包含元素值和索引 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数 + * @param objects 要遍历的布尔可变参数数组 + */ + private static void forEach( + P2Function action, + boolean... objects + ) { + forEach(Lists.toList(objects), action); + } + /** + * 对布尔可变参数数组执行指定的操作，仅处理元素值 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数 + * @param objects 要遍历的布尔可变参数数组 + */ + private static void forEach( + P1Function action, + boolean... objects + ) { + forEach(Lists.toList(objects), action); + } } diff --git a/src/main/java/com/mingliqiye/utils/collection/ForEachBreaked.java b/src/main/java/com/mingliqiye/utils/collection/ForEachBreaked.java index 67b94ba..585c9d5 100644 --- a/src/main/java/com/mingliqiye/utils/collection/ForEachBreaked.java +++ b/src/main/java/com/mingliqiye/utils/collection/ForEachBreaked.java @@ -25,7 +25,6 @@ package com.mingliqiye.utils.collection; import com.mingliqiye.utils.functions.P1RFunction; import com.mingliqiye.utils.functions.P2RFunction; import com.mingliqiye.utils.functions.P3RFunction; - import java.util.*; import java.util.Collection; import java.util.concurrent.ConcurrentMap; @@ -47,469 +46,570 @@ import java.util.concurrent.ConcurrentMap; */ public class ForEachBreaked { - /** - * 对给定的集合执行指定的操作，操作包含元素值和索引。 - * 根据集合类型选择最优的遍历方式以提高性能。 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param collection 要遍历的集合，可以是 List 或其他 Collection 实现 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param 集合中元素的类型 - */ - public static void forEach(Collection collection, P2RFunction action) { - // 参数校验：如果集合或操作为空，则直接返回 - if (collection == null || action == null) { - return; - } + /** + * 对给定的集合执行指定的操作，操作包含元素值和索引。 + * 根据集合类型选择最优的遍历方式以提高性能。 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param collection 要遍历的集合，可以是 List 或其他 Collection 实现 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param 集合中元素的类型 + */ + public static void forEach( + Collection collection, + P2RFunction action + ) { + // 参数校验：如果集合或操作为空，则直接返回 + if (collection == null || action == null) { + return; + } - // 如果集合实现了 RandomAccess 接口（如 ArrayList），使用索引访问优化性能 - if (collection instanceof RandomAccess && collection instanceof List) { - List list = (List) collection; - for (int i = 0; i < list.size(); i++) { - if (action.call(list.get(i), i)) return; - } - } - // 如果是普通 List，使用迭代器遍历并手动维护索引 - else if (collection instanceof List) { - int index = 0; - Iterator it = collection.iterator(); - while (it.hasNext()) { - if (action.call(it.next(), index)) return; - index++; - } - } - // 其他类型的集合使用增强 for 循环，并手动维护索引 - else { - int index = 0; - for (T element : collection) { - if (action.call(element, index)) return; - index++; - } - } - } + // 如果集合实现了 RandomAccess 接口（如 ArrayList），使用索引访问优化性能 + if (collection instanceof RandomAccess && collection instanceof List) { + List list = (List) collection; + for (int i = 0; i < list.size(); i++) { + if (action.call(list.get(i), i)) return; + } + } + // 如果是普通 List，使用迭代器遍历并手动维护索引 + else if (collection instanceof List) { + int index = 0; + Iterator it = collection.iterator(); + while (it.hasNext()) { + if (action.call(it.next(), index)) return; + index++; + } + } + // 其他类型的集合使用增强 for 循环，并手动维护索引 + else { + int index = 0; + for (T element : collection) { + if (action.call(element, index)) return; + index++; + } + } + } - /** - * 对给定的集合执行指定的操作，仅处理元素值。 - * 根据集合是否实现 RandomAccess 接口选择最优的遍历方式。 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param collection 要遍历的集合 - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param 集合中元素的类型 - */ - public static void forEach(Collection collection, P1RFunction action) { - // 参数校验：如果集合或操作为空，则直接返回 - if (collection == null || action == null) { - return; - } + /** + * 对给定的集合执行指定的操作，仅处理元素值。 + * 根据集合是否实现 RandomAccess 接口选择最优的遍历方式。 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param collection 要遍历的集合 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param 集合中元素的类型 + */ + public static void forEach( + Collection collection, + P1RFunction action + ) { + // 参数校验：如果集合或操作为空，则直接返回 + if (collection == null || action == null) { + return; + } - // 如果集合实现了 RandomAccess 接口，使用索引访问提升性能 - if (collection instanceof RandomAccess) { - List list = (List) collection; - for (int i = 0; i < list.size(); i++) { - if (action.call(list.get(i))) return; - } - } - // 否则使用增强 for 循环进行遍历 - else { - for (T element : collection) { - if (action.call(element)) return; - } - } - } + // 如果集合实现了 RandomAccess 接口，使用索引访问提升性能 + if (collection instanceof RandomAccess) { + List list = (List) collection; + for (int i = 0; i < list.size(); i++) { + if (action.call(list.get(i))) return; + } + } + // 否则使用增强 for 循环进行遍历 + else { + for (T element : collection) { + if (action.call(element)) return; + } + } + } - /** - * 对给定的映射执行指定的操作，操作包含键、值和索引。 - * 根据映射类型选择不同的遍历策略。 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param map 要遍历的映射 - * @param action 要对每个键值对执行的操作，接收键、值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param 映射中键的类型 - * @param 映射中值的类型 - */ - public static void forEach(Map map, P3RFunction action) { - // 参数校验：如果映射或操作为空，则直接返回 - if (map == null || action == null) { - return; - } + /** + * 对给定的映射执行指定的操作，操作包含键、值和索引。 + * 根据映射类型选择不同的遍历策略。 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param map 要遍历的映射 + * @param action 要对每个键值对执行的操作，接收键、值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param 映射中键的类型 + * @param 映射中值的类型 + */ + public static void forEach( + Map map, + P3RFunction action + ) { + // 参数校验：如果映射或操作为空，则直接返回 + if (map == null || action == null) { + return; + } - // 遍历 TreeMap 的条目集合并传递索引 - if (map instanceof TreeMap) { - int index = 0; - for (Map.Entry entry : map.entrySet()) { - if (action.call(entry.getKey(), entry.getValue(), index)) return; - index++; - } - } - // 遍历 ConcurrentMap 或 LinkedHashMap 的条目集合并传递索引 - else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) { - int index = 0; - for (Map.Entry entry : map.entrySet()) { - if (action.call(entry.getKey(), entry.getValue(), index)) return; - index++; - } - } - // 遍历其他类型映射的条目集合并传递索引 - else { - int index = 0; - for (Map.Entry entry : map.entrySet()) { - if (action.call(entry.getKey(), entry.getValue(), index)) return; - index++; - } - } - } + // 遍历 TreeMap 的条目集合并传递索引 + if (map instanceof TreeMap) { + int index = 0; + for (Map.Entry entry : map.entrySet()) { + if ( + action.call(entry.getKey(), entry.getValue(), index) + ) return; + index++; + } + } + // 遍历 ConcurrentMap 或 LinkedHashMap 的条目集合并传递索引 + else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) { + int index = 0; + for (Map.Entry entry : map.entrySet()) { + if ( + action.call(entry.getKey(), entry.getValue(), index) + ) return; + index++; + } + } + // 遍历其他类型映射的条目集合并传递索引 + else { + int index = 0; + for (Map.Entry entry : map.entrySet()) { + if ( + action.call(entry.getKey(), entry.getValue(), index) + ) return; + index++; + } + } + } - /** - * 对给定的映射执行指定的操作，仅处理键和值。 - * 根据映射类型选择不同的遍历策略。 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param map 要遍历的映射 - * @param action 要对每个键值对执行的操作，接收键和值作为参数，返回 Boolean 值决定是否继续遍历 - * @param 映射中键的类型 - * @param 映射中值的类型 - */ - public static void forEach(Map map, P2RFunction action) { - // 参数校验：如果映射或操作为空，则直接返回 - if (map == null || action == null) { - return; - } + /** + * 对给定的映射执行指定的操作，仅处理键和值。 + * 根据映射类型选择不同的遍历策略。 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param map 要遍历的映射 + * @param action 要对每个键值对执行的操作，接收键和值作为参数，返回 Boolean 值决定是否继续遍历 + * @param 映射中键的类型 + * @param 映射中值的类型 + */ + public static void forEach( + Map map, + P2RFunction action + ) { + // 参数校验：如果映射或操作为空，则直接返回 + if (map == null || action == null) { + return; + } - // 遍历 TreeMap 的条目集合 - if (map instanceof TreeMap) { - for (Map.Entry entry : map.entrySet()) { - if (action.call(entry.getKey(), entry.getValue())) return; - } - } - // 如果是 ConcurrentMap 或 LinkedHashMap，使用其内置的 forEach 方法 - else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) { - forEach(map.entrySet(), (i) -> { - if (action.call(i.getKey(), i.getValue())) return true; - return false; - }); - } - // 遍历其他类型映射的条目集合 - else { - for (Map.Entry entry : map.entrySet()) { - if (action.call(entry.getKey(), entry.getValue())) return; - } - } - } + // 遍历 TreeMap 的条目集合 + if (map instanceof TreeMap) { + for (Map.Entry entry : map.entrySet()) { + if (action.call(entry.getKey(), entry.getValue())) return; + } + } + // 如果是 ConcurrentMap 或 LinkedHashMap，使用其内置的 forEach 方法 + else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) { + forEach(map.entrySet(), i -> { + if (action.call(i.getKey(), i.getValue())) return true; + return false; + }); + } + // 遍历其他类型映射的条目集合 + else { + for (Map.Entry entry : map.entrySet()) { + if (action.call(entry.getKey(), entry.getValue())) return; + } + } + } - /** - * 对可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的可变参数数组 - * @param 数组中元素的类型 - */ - public static void forEach(P2RFunction action, T... objects) { - forEach(Lists.newArrayList(objects), action); - } + /** + * 对可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的可变参数数组 + * @param 数组中元素的类型 + */ + public static void forEach( + P2RFunction action, + T... objects + ) { + forEach(Lists.newArrayList(objects), action); + } - /** - * 对数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param 数组中元素的类型 - */ - public static void forEach(T[] objects, P2RFunction action) { - forEach(action, objects); - } + /** + * 对数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param 数组中元素的类型 + */ + public static void forEach( + T[] objects, + P2RFunction action + ) { + forEach(action, objects); + } - /** - * 对数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的数组 - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param 数组中元素的类型 - */ - public static void forEach(T[] objects, P1RFunction action) { - forEach(action, objects); - } + /** + * 对数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的数组 + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param 数组中元素的类型 + */ + public static void forEach( + T[] objects, + P1RFunction action + ) { + forEach(action, objects); + } - /** - * 对可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的可变参数数组 - * @param 数组中元素的类型 - */ - public static void forEach(P1RFunction action, T... objects) { - forEach(Lists.toList(objects), (t, i) -> { - if (action.call(t)) return true; - return false; - }); - } + /** + * 对可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的可变参数数组 + * @param 数组中元素的类型 + */ + public static void forEach( + P1RFunction action, + T... objects + ) { + forEach(Lists.toList(objects), (t, i) -> { + if (action.call(t)) return true; + return false; + }); + } - /** - * 对整型数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的整型数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - */ - public static void forEach(int[] objects, P2RFunction action) { - forEach(action, objects); - } + /** + * 对整型数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + */ + public static void forEach( + int[] objects, + P2RFunction action + ) { + forEach(action, objects); + } - /** - * 对整型可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的整型可变参数数组 - */ - private static void forEach(P2RFunction action, int... objects) { - forEach(objects, action); - } + /** + * 对整型可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的整型可变参数数组 + */ + private static void forEach( + P2RFunction action, + int... objects + ) { + forEach(objects, action); + } - /** - * 对整型可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的整型可变参数数组 - */ - private static void forEach(P1RFunction action, int... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对整型可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的整型可变参数数组 + */ + private static void forEach( + P1RFunction action, + int... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对字节数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的字节数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - */ - public static void forEach(byte[] objects, P2RFunction action) { - forEach(Lists.toList(objects), action); - } + /** + * 对字节数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的字节数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + */ + public static void forEach( + byte[] objects, + P2RFunction action + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对字节可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的字节可变参数数组 - */ - private static void forEach(P2RFunction action, byte... objects) { - forEach(objects, action); - } + /** + * 对字节可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的字节可变参数数组 + */ + private static void forEach( + P2RFunction action, + byte... objects + ) { + forEach(objects, action); + } - /** - * 对字节可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的字节可变参数数组 - */ - private static void forEach(P1RFunction action, byte... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对字节可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的字节可变参数数组 + */ + private static void forEach( + P1RFunction action, + byte... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对短整型数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的短整型数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - */ - public static void forEach(short[] objects, P2RFunction action) { - forEach(Lists.toList(objects), action); - } + /** + * 对短整型数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的短整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + */ + public static void forEach( + short[] objects, + P2RFunction action + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对短整型可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的短整型可变参数数组 - */ - private static void forEach(P2RFunction action, short... objects) { - forEach(objects, action); - } + /** + * 对短整型可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的短整型可变参数数组 + */ + private static void forEach( + P2RFunction action, + short... objects + ) { + forEach(objects, action); + } - /** - * 对短整型可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的短整型可变参数数组 - */ - private static void forEach(P1RFunction action, short... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对短整型可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的短整型可变参数数组 + */ + private static void forEach( + P1RFunction action, + short... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对长整型数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的长整型数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - */ - public static void forEach(long[] objects, P2RFunction action) { - forEach(action, objects); - } + /** + * 对长整型数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的长整型数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + */ + public static void forEach( + long[] objects, + P2RFunction action + ) { + forEach(action, objects); + } - /** - * 对长整型可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的长整型可变参数数组 - */ - private static void forEach(P2RFunction action, long... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对长整型可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的长整型可变参数数组 + */ + private static void forEach( + P2RFunction action, + long... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对长整型可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的长整型可变参数数组 - */ - private static void forEach(P1RFunction action, long... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对长整型可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的长整型可变参数数组 + */ + private static void forEach( + P1RFunction action, + long... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对浮点数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的浮点数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - */ - public static void forEach(float[] objects, P2RFunction action) { - forEach(action, objects); - } + /** + * 对浮点数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的浮点数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + */ + public static void forEach( + float[] objects, + P2RFunction action + ) { + forEach(action, objects); + } - /** - * 对浮点可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的浮点可变参数数组 - */ - private static void forEach(P2RFunction action, float... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对浮点可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的浮点可变参数数组 + */ + private static void forEach( + P2RFunction action, + float... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对浮点可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的浮点可变参数数组 - */ - private static void forEach(P1RFunction action, float... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对浮点可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的浮点可变参数数组 + */ + private static void forEach( + P1RFunction action, + float... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对双精度浮点数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的双精度浮点数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - */ - public static void forEach(double[] objects, P2RFunction action) { - forEach(action, objects); - } + /** + * 对双精度浮点数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的双精度浮点数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + */ + public static void forEach( + double[] objects, + P2RFunction action + ) { + forEach(action, objects); + } - /** - * 对双精度浮点可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的双精度浮点可变参数数组 - */ - private static void forEach(P2RFunction action, double... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对双精度浮点可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的双精度浮点可变参数数组 + */ + private static void forEach( + P2RFunction action, + double... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对双精度浮点可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的双精度浮点可变参数数组 - */ - private static void forEach(P1RFunction action, double... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对双精度浮点可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的双精度浮点可变参数数组 + */ + private static void forEach( + P1RFunction action, + double... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对字符数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的字符数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - */ - public static void forEach(char[] objects, P2RFunction action) { - forEach(action, objects); - } + /** + * 对字符数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的字符数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + */ + public static void forEach( + char[] objects, + P2RFunction action + ) { + forEach(action, objects); + } - /** - * 对字符可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的字符可变参数数组 - */ - private static void forEach(P2RFunction action, char... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对字符可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的字符可变参数数组 + */ + private static void forEach( + P2RFunction action, + char... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对字符可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的字符可变参数数组 - */ - private static void forEach(P1RFunction action, char... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对字符可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的字符可变参数数组 + */ + private static void forEach( + P1RFunction action, + char... objects + ) { + forEach(Lists.toList(objects), action); + } - /** - * 对布尔数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param objects 要遍历的布尔数组 - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - */ - public static void forEach(boolean[] objects, P2RFunction action) { - forEach(objects, action); - } + /** + * 对布尔数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param objects 要遍历的布尔数组 + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + */ + public static void forEach( + boolean[] objects, + P2RFunction action + ) { + forEach(objects, action); + } - /** - * 对布尔可变参数数组执行指定的操作，操作包含元素值和索引 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的布尔可变参数数组 - */ - private static void forEach(P2RFunction action, boolean... objects) { - forEach(Lists.toList(objects), action); - } - - /** - * 对布尔可变参数数组执行指定的操作，仅处理元素值 - * 当操作返回 true 时，遍历将提前终止。 - * - * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 - * @param objects 要遍历的布尔可变参数数组 - */ - private static void forEach(P1RFunction action, boolean... objects) { - forEach(Lists.toList(objects), action); - } + /** + * 对布尔可变参数数组执行指定的操作，操作包含元素值和索引 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的布尔可变参数数组 + */ + private static void forEach( + P2RFunction action, + boolean... objects + ) { + forEach(Lists.toList(objects), action); + } + /** + * 对布尔可变参数数组执行指定的操作，仅处理元素值 + * 当操作返回 true 时，遍历将提前终止。 + * + * @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历 + * @param objects 要遍历的布尔可变参数数组 + */ + private static void forEach( + P1RFunction action, + boolean... objects + ) { + forEach(Lists.toList(objects), action); + } } diff --git a/src/main/java/com/mingliqiye/utils/collection/Lists.java b/src/main/java/com/mingliqiye/utils/collection/Lists.java index 790ac54..33bf55d 100644 --- 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 List toList(Stream ts) { + return ts == null + ? newArrayList() + : new ArrayList<>(ts.collect(Collectors.toList())); + } + /** * 将int数组转换为Integer列表 * @@ -442,4 +456,20 @@ public class Lists { } return list; } + + public T getFirst(Collection collectors) { + return com.mingliqiye.utils.collection.Collection.getFirst(collectors); + } + + public T getLast(Collection collectors) { + return com.mingliqiye.utils.collection.Collection.getFirst(collectors); + } + + public T getAny(Collection collectors) { + return com.mingliqiye.utils.collection.Collection.getOrDefault( + collectors, + RandomInt.randomInt(0, collectors.size()), + null + ); + } } diff --git a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java index 73d8d2c..1e39a0e 100644 --- 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 = diff --git a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/DateTimeToStringConverter.java b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/DateTimeToStringConverter.java new file mode 100644 index 0000000..e369eea --- /dev/null +++ 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 { + + @Override + public String convert(@NotNull DateTime source) { + return source.format(STANDARD_DATETIME); + } +} diff --git a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToDateTimeConverter.java b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToDateTimeConverter.java new file mode 100644 index 0000000..60bd566 --- /dev/null +++ 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 { + + @Override + public DateTime convert(@NotNull String source) { + return DateTime.parse(source, STANDARD_DATETIME_MILLISECOUND7, true); + } +} diff --git a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToUUIDConverter.java b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToUUIDConverter.java new file mode 100644 index 0000000..74d465a --- /dev/null +++ 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 { + + @Override + public UUID convert(@NotNull String source) { + return UUID.of(source); + } +} diff --git a/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/UUIDToStringConverter.java b/src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/UUIDToStringConverter.java new file mode 100644 index 0000000..a0a58a0 --- /dev/null +++ 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 { + + @Override + public String convert(@NotNull UUID source) { + return source.toUUIDString(); + } +} diff --git a/src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java b/src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java index 0da7602..6af8348 100644 --- 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 { /** * 将输入流读取为字符串
* 请在外部自行关闭输入流对象 避免资源泄露 + * * @param inputStream 输入流对象，用于读取数据 * @return 输入流对应的字符串内容 * @throws IOException 当读取输入流时发生IO异常 diff --git a/src/main/java/com/mingliqiye/utils/stream/SuperStream.java b/src/main/java/com/mingliqiye/utils/stream/SuperStream.java index 60d3b8b..e558460 100644 --- a/src/main/java/com/mingliqiye/utils/stream/SuperStream.java +++ b/src/main/java/com/mingliqiye/utils/stream/SuperStream.java @@ -22,11 +22,14 @@ package com.mingliqiye.utils.stream; +import com.mingliqiye.utils.collection.Lists; import com.mingliqiye.utils.collection.Maps; +import com.mingliqiye.utils.stream.interfaces.Getable; import java.util.*; import java.util.concurrent.ConcurrentMap; import java.util.function.*; import java.util.stream.*; +import lombok.val; import org.jetbrains.annotations.NotNull; /** @@ -38,707 +41,6 @@ import org.jetbrains.annotations.NotNull; */ public class SuperStream implements Stream { - /** - * 内部静态类 Collectors，用于提供常用的收集器实现。 - * 所有方法均是对 java.util.stream.Collectors 的封装或扩展。 - */ - public static class Collectors { - - /** - * 返回一个收集器，用于将元素映射为 long 值并求和。 - * - * @param mapper 映射函数，将元素转换为 long 值 - * @param 元素类型 - * @return 收集器 - */ - public static Collector summingLong( - @NotNull ToLongFunction mapper - ) { - return java.util.stream.Collectors.summingLong(mapper); - } - - /** - * 返回一个收集器，将元素收集到指定类型的集合中。 - * - * @param collectionFactory 集合工厂，用于创建目标集合 - * @param 元素类型 - * @param 目标集合类型 - * @return 收集器 - */ - public static > Collector< - T, - ?, - C - > toCollection(@NotNull Supplier collectionFactory) { - return java.util.stream.Collectors.toCollection(collectionFactory); - } - - /** - * 返回一个收集器，将元素收集到 List 中。 - * - * @param 元素类型 - * @return 收集器 - */ - public static Collector> toList() { - return java.util.stream.Collectors.toList(); - } - - /** - * 返回一个收集器，将元素收集到 Set 中。 - * - * @param 元素类型 - * @return 收集器 - */ - public static Collector> toSet() { - return java.util.stream.Collectors.toSet(); - } - - /** - * 返回一个收集器，将字符序列连接成字符串。 - * - * @return 收集器 - */ - public static Collector joining() { - return java.util.stream.Collectors.joining(); - } - - /** - * 返回一个收集器，将字符序列使用指定分隔符连接成字符串。 - * - * @param delimiter 分隔符 - * @return 收集器 - */ - public static Collector joining( - @NotNull CharSequence delimiter - ) { - return java.util.stream.Collectors.joining(delimiter); - } - - /** - * 返回一个收集器，将字符序列使用指定前缀、后缀和分隔符连接成字符串。 - * - * @param delimiter 分隔符 - * @param prefix 前缀 - * @param suffix 后缀 - * @return 收集器 - */ - public static Collector joining( - @NotNull CharSequence delimiter, - @NotNull CharSequence prefix, - @NotNull CharSequence suffix - ) { - return java.util.stream.Collectors.joining( - delimiter, - prefix, - suffix - ); - } - - /** - * 返回一个收集器，先对元素进行映射，再使用下游收集器进行收集。 - * - * @param mapper 映射函数 - * @param downstream 下游收集器 - * @param 输入元素类型 - * @param 映射后的元素类型 - * @param 下游收集器的中间结果类型 - * @param 最终结果类型 - * @return 收集器 - */ - public static Collector mapping( - @NotNull Function mapper, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.mapping(mapper, downstream); - } - - /** - * 返回一个收集器，在下游收集完成后应用 finisher 函数。 - * - * @param downstream 下游收集器 - * @param finisher 完成后应用的函数 - * @param 元素类型 - * @param 下游收集器的中间结果类型 - * @param 下游收集器的结果类型 - * @param 最终结果类型 - * @return 收集器 - */ - public static Collector collectingAndThen( - @NotNull Collector downstream, - @NotNull Function finisher - ) { - return java.util.stream.Collectors.collectingAndThen( - downstream, - finisher - ); - } - - /** - * 返回一个收集器，用于统计元素数量。 - * - * @param 元素类型 - * @return 收集器 - */ - public static Collector counting() { - return java.util.stream.Collectors.counting(); - } - - /** - * 返回一个收集器，找出最小元素。 - * - * @param comparator 比较器 - * @param 元素类型 - * @return 收集器 - */ - public static Collector> minBy( - @NotNull Comparator comparator - ) { - return java.util.stream.Collectors.minBy(comparator); - } - - /** - * 返回一个收集器，找出最大元素。 - * - * @param comparator 比较器 - * @param 元素类型 - * @return 收集器 - */ - public static Collector> maxBy( - @NotNull Comparator comparator - ) { - return java.util.stream.Collectors.maxBy(comparator); - } - - /** - * 返回一个收集器，将元素映射为 int 值并求和。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector summingInt( - @NotNull ToIntFunction mapper - ) { - return java.util.stream.Collectors.summingInt(mapper); - } - - /** - * 返回一个收集器，将元素映射为 double 值并求和。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector summingDouble( - @NotNull ToDoubleFunction mapper - ) { - return java.util.stream.Collectors.summingDouble(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 int 值的平均值。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector averagingInt( - @NotNull ToIntFunction mapper - ) { - return java.util.stream.Collectors.averagingInt(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 long 值的平均值。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector averagingLong( - @NotNull ToLongFunction mapper - ) { - return java.util.stream.Collectors.averagingLong(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 double 值的平均值。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector averagingDouble( - @NotNull ToDoubleFunction mapper - ) { - return java.util.stream.Collectors.averagingDouble(mapper); - } - - /** - * 返回一个收集器，使用指定的初始值和二元操作符进行归约。 - * - * @param identity 初始值 - * @param op 二元操作符 - * @param 元素类型 - * @return 收集器 - */ - public static Collector reducing( - T identity, - @NotNull BinaryOperator op - ) { - return java.util.stream.Collectors.reducing(identity, op); - } - - /** - * 返回一个收集器，使用指定的二元操作符进行归约。 - * - * @param op 二元操作符 - * @param 元素类型 - * @return 收集器 - */ - public static Collector> reducing( - @NotNull BinaryOperator op - ) { - return java.util.stream.Collectors.reducing(op); - } - - /** - * 返回一个收集器，先对元素进行映射，再使用指定的初始值和二元操作符进行归约。 - * - * @param identity 初始值 - * @param mapper 映射函数 - * @param op 二元操作符 - * @param 元素类型 - * @param 映射后的元素类型 - * @return 收集器 - */ - public static Collector reducing( - U identity, - @NotNull Function mapper, - @NotNull BinaryOperator op - ) { - return java.util.stream.Collectors.reducing(identity, mapper, op); - } - - /** - * 返回一个收集器，按分类器对元素进行分组。 - * - * @param classifier 分类器函数 - * @param 元素类型 - * @param 分类键类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map> - > groupingBy(@NotNull Function classifier) { - return java.util.stream.Collectors.groupingBy(classifier); - } - - /** - * 返回一个收集器，按分类器对元素进行分组，并使用下游收集器处理每个组。 - * - * @param classifier 分类器函数 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 分类键类型 - * @param 下游收集器的中间结果类型 - * @param 下游收集器的结果类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map - > groupingBy( - @NotNull Function classifier, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.groupingBy( - classifier, - downstream - ); - } - - /** - * 返回一个收集器，按分类器对元素进行分组，并使用指定的 Map 工厂和下游收集器。 - * - * @param classifier 分类器函数 - * @param mapFactory Map 工厂 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 分类键类型 - * @param 下游收集器的结果类型 - * @param 下游收集器的中间结果类型 - * @param Map 类型 - * @return 收集器 - */ - public static > Collector< - T, - ?, - M - > groupingBy( - @NotNull Function classifier, - @NotNull Supplier mapFactory, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.groupingBy( - classifier, - mapFactory, - downstream - ); - } - - /** - * 返回一个并发收集器，按分类器对元素进行分组。 - * - * @param classifier 分类器函数 - * @param 元素类型 - * @param 分类键类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull ConcurrentMap> - > groupingByConcurrent( - @NotNull Function classifier - ) { - return java.util.stream.Collectors.groupingByConcurrent(classifier); - } - - /** - * 返回一个并发收集器，按分类器对元素进行分组，并使用下游收集器处理每个组。 - * - * @param classifier 分类器函数 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 分类键类型 - * @param 下游收集器的中间结果类型 - * @param 下游收集器的结果类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull ConcurrentMap - > groupingByConcurrent( - @NotNull Function classifier, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.groupingByConcurrent( - classifier, - downstream - ); - } - - /** - * 返回一个并发收集器，按分类器对元素进行分组，并使用指定的 Map 工厂和下游收集器。 - * - * @param classifier 分类器函数 - * @param mapFactory Map 工厂 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 分类键类型 - * @param 下游收集器的结果类型 - * @param 下游收集器的中间结果类型 - * @param Map 类型 - * @return 收集器 - */ - public static > Collector< - T, - ?, - M - > groupingByConcurrent( - @NotNull Function classifier, - @NotNull Supplier mapFactory, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.groupingByConcurrent( - classifier, - mapFactory, - downstream - ); - } - - /** - * 返回一个收集器，按谓词对元素进行分区。 - * - * @param predicate 谓词函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map<@NotNull Boolean, @NotNull List> - > partitioningBy(@NotNull Predicate predicate) { - return java.util.stream.Collectors.partitioningBy(predicate); - } - - /** - * 返回一个收集器，按谓词对元素进行分区，并使用下游收集器处理每个分区。 - * - * @param predicate 谓词函数 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 下游收集器的结果类型 - * @param 下游收集器的中间结果类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map<@NotNull Boolean, D> - > partitioningBy( - @NotNull Predicate predicate, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.partitioningBy( - predicate, - downstream - ); - } - - /** - * 返回一个收集器，将元素转换为 Map。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map - > toMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper - ) { - return java.util.stream.Collectors.toMap(keyMapper, valueMapper); - } - - /** - * 返回一个收集器，将元素转换为 Map，并指定合并函数。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param mergeFunction 合并函数 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map - > toMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper, - @NotNull BinaryOperator mergeFunction - ) { - return java.util.stream.Collectors.toMap( - keyMapper, - valueMapper, - mergeFunction - ); - } - - /** - * 返回一个收集器，将元素转换为 Map，并指定合并函数和 Map 工厂。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param mergeFunction 合并函数 - * @param mapSupplier Map 工厂 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @param Map 类型 - * @return 收集器 - */ - public static > Collector toMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper, - @NotNull BinaryOperator mergeFunction, - @NotNull Supplier mapSupplier - ) { - return java.util.stream.Collectors.toMap( - keyMapper, - valueMapper, - mergeFunction, - mapSupplier - ); - } - - /** - * 返回一个并发收集器，将元素转换为 ConcurrentMap。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull ConcurrentMap - > toConcurrentMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper - ) { - return java.util.stream.Collectors.toConcurrentMap( - keyMapper, - valueMapper - ); - } - - /** - * 返回一个并发收集器，将元素转换为 ConcurrentMap，并指定合并函数。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param mergeFunction 合并函数 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull ConcurrentMap - > toConcurrentMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper, - @NotNull BinaryOperator mergeFunction - ) { - return java.util.stream.Collectors.toConcurrentMap( - keyMapper, - valueMapper, - mergeFunction - ); - } - - /** - * 返回一个并发收集器，将元素转换为 ConcurrentMap，并指定合并函数和 Map 工厂。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param mergeFunction 合并函数 - * @param mapSupplier Map 工厂 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @param Map 类型 - * @return 收集器 - */ - public static > Collector< - T, - ?, - M - > toConcurrentMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper, - @NotNull BinaryOperator mergeFunction, - @NotNull Supplier mapSupplier - ) { - return java.util.stream.Collectors.toConcurrentMap( - keyMapper, - valueMapper, - mergeFunction, - mapSupplier - ); - } - - /** - * 返回一个收集器，计算元素映射为 int 值的统计信息。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull IntSummaryStatistics - > summarizingInt(@NotNull ToIntFunction mapper) { - return java.util.stream.Collectors.summarizingInt(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 long 值的统计信息。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull LongSummaryStatistics - > summarizingLong(@NotNull ToLongFunction mapper) { - return java.util.stream.Collectors.summarizingLong(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 double 值的统计信息。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull DoubleSummaryStatistics - > summarizingDouble(@NotNull ToDoubleFunction mapper) { - return java.util.stream.Collectors.summarizingDouble(mapper); - } - - /** - * 返回当前元素本身。 - * - * @param t 元素 - * @param 元素类型 - * @return 元素本身 - */ - public static T getThis(T t) { - return t; - } - - /** - * 返回一个收集器，将元素收集到 List 中。 - * - * @param 元素类型 - * @return 收集器 - */ - public static Collector> toMap() { - return Collectors.toList(); - } - - /** - * 返回一个收集器，将元素转换为 Map，键由 keyMapper 生成，值为元素本身。 - * - * @param keyMapper 键映射函数 - * @param 元素类型 - * @param 键类型 - * @return 收集器 - */ - public static Collector> toMap( - @NotNull Function keyMapper - ) { - return Collectors.toMap(keyMapper, Collectors::getThis); - } - } - /** * 内部流对象，用于执行实际的流操作。 */ @@ -753,6 +55,179 @@ public class SuperStream implements Stream { this.stream = stream; } + /** + * 创建一个 SuperStream 实例，基于给定的集合。 + * + * @param collection 集合 + * @param parallel 是否并行流 + * @param 元素类型 + * @return SuperStream 实例 + */ + public static SuperStream of( + Collection collection, + boolean parallel + ) { + return new SuperStream<>( + parallel ? collection.parallelStream() : collection.stream() + ); + } + + /** + * 创建一个 SuperStream 实例，基于给定的集合。 + * + * @param collection 集合 + * @param 元素类型 + * @return SuperStream 实例 + */ + public static SuperStream of(Collection collection) { + return of(collection, false); + } + + /** + * 创建一个 SuperStream 实例，基于给定的 Map。 + * + * @param map Map + * @param parallel 是否并行流 + * @param 键类型 + * @param 值类型 + * @return SuperStream 实例 + */ + public static SuperStream> of( + Map map, + boolean parallel + ) { + return new SuperStream<>( + parallel ? map.entrySet().parallelStream() : map.entrySet().stream() + ); + } + + /** + * 创建一个 SuperStream 实例，基于给定的 Map。 + * + * @param map Map + * @param 键类型 + * @param 值类型 + * @return SuperStream 实例 + */ + public static SuperStream> of(Map map) { + return of(map, false); + } + + /** + * 创建一个 SuperStream 构建器。 + * + * @param 元素类型 + * @return 构建器 + */ + public static Builder builder() { + return new Builder() { + private final List list = new ArrayList<>(); + + @Override + public void accept(T t) { + list.add(t); + } + + @Override + public @NotNull SuperStream build() { + return new SuperStream<>(list.stream()); + } + }; + } + + /** + * 创建一个空的 SuperStream 实例。 + * + * @param 元素类型 + * @return SuperStream 实例 + */ + public static @NotNull SuperStream empty() { + return new SuperStream<>(Stream.empty()); + } + + /** + * 创建一个包含单个元素的 SuperStream 实例。 + * + * @param t 元素 + * @param 元素类型 + * @return SuperStream 实例 + */ + public static @NotNull SuperStream of(T t) { + return new SuperStream<>(Stream.of(t)); + } + + /** + * 创建一个包含多个元素的 SuperStream 实例。 + * + * @param values 元素数组 + * @param 元素类型 + * @return SuperStream 实例 + */ + @SafeVarargs + public static @NotNull SuperStream of(T... values) { + return new SuperStream<>(Stream.of(values)); + } + + /** + * 创建一个无限流，使用指定的种子和函数生成元素。 + * + * @param seed 种子 + * @param f 函数 + * @param 元素类型 + * @return SuperStream 实例 + */ + public static @NotNull SuperStream iterate( + T seed, + UnaryOperator f + ) { + return new SuperStream<>(Stream.iterate(seed, f)); + } + + /** + * 创建一个无限流，使用指定的供应商生成元素。 + * + * @param s 供应商 + * @param 元素类型 + * @return SuperStream 实例 + */ + public static @NotNull SuperStream generate(Supplier s) { + return new SuperStream<>(Stream.generate(s)); + } + + /** + * 连接两个流。 + * + * @param a 第一个流 + * @param b 第二个流 + * @param 元素类型 + * @return SuperStream 实例 + */ + public static @NotNull SuperStream concat( + @NotNull Stream a, + @NotNull Stream b + ) { + return new SuperStream<>(Stream.concat(a, b)); + } + + public T get(int index) { + return find(index).orElse(null); + } + + public Optional find(int index) { + if (index < 0 || index >= size()) { + return Optional.empty(); + } + return Optional.of(toList().get(index)); + } + + public boolean isEmpty() { + return !findAny().isPresent(); + } + + public long size() { + return count(); + } + /** * 将流中的元素收集到 List 中。 * @@ -775,7 +250,7 @@ public class SuperStream implements Stream { * 将流中的元素转换为 Map，键由 mapper 生成，值为元素本身。 * * @param mapper 键映射函数 - * @param 键类型 + * @param 键类型 * @return 包含流中所有元素的 Map */ public Map toMap(Function mapper) { @@ -794,64 +269,6 @@ public class SuperStream implements Stream { return Maps.ofEntries((List>) toList()); } - /** - * 创建一个 SuperStream 实例，基于给定的集合。 - * - * @param collection 集合 - * @param parallel 是否并行流 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static SuperStream of( - Collection collection, - boolean parallel - ) { - return new SuperStream<>( - parallel ? collection.parallelStream() : collection.stream() - ); - } - - /** - * 创建一个 SuperStream 实例，基于给定的集合。 - * - * @param collection 集合 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static SuperStream of(Collection collection) { - return of(collection, false); - } - - /** - * 创建一个 SuperStream 实例，基于给定的 Map。 - * - * @param map Map - * @param parallel 是否并行流 - * @param 键类型 - * @param 值类型 - * @return SuperStream 实例 - */ - public static SuperStream> of( - Map map, - boolean parallel - ) { - return new SuperStream<>( - parallel ? map.entrySet().parallelStream() : map.entrySet().stream() - ); - } - - /** - * 创建一个 SuperStream 实例，基于给定的 Map。 - * - * @param map Map - * @param 键类型 - * @param 值类型 - * @return SuperStream 实例 - */ - public static SuperStream> of(Map map) { - return of(map, false); - } - /** * 返回一个顺序流。 * @@ -887,7 +304,7 @@ public class SuperStream implements Stream { * 映射流中的元素。 * * @param mapper 映射函数 - * @param 映射后的元素类型 + * @param 映射后的元素类型 * @return SuperStream 实例 */ @Override @@ -899,7 +316,7 @@ public class SuperStream implements Stream { * 扁平化映射流中的元素。 * * @param mapper 映射函数 - * @param 映射后的元素类型 + * @param 映射后的元素类型 * @return SuperStream 实例 */ @Override @@ -1079,7 +496,7 @@ public class SuperStream implements Stream { * 将流中的元素转换为指定类型的数组。 * * @param generator 数组生成器 - * @param 数组元素类型 + * @param 数组元素类型 * @return 包含流中所有元素的数组 */ @Override @@ -1090,7 +507,7 @@ public class SuperStream implements Stream { /** * 使用指定的初始值和累加器对流中的元素进行归约。 * - * @param identity 初始值 + * @param identity 初始值 * @param accumulator 累加器 * @return 归约结果 */ @@ -1113,10 +530,10 @@ public class SuperStream implements Stream { /** * 使用指定的初始值、累加器和组合器对流中的元素进行归约。 * - * @param identity 初始值 + * @param identity 初始值 * @param accumulator 累加器 - * @param combiner 组合器 - * @param 归约结果类型 + * @param combiner 组合器 + * @param 归约结果类型 * @return 归约结果 */ @Override @@ -1131,10 +548,10 @@ public class SuperStream implements Stream { /** * 使用指定的供应商、累加器和组合器对流中的元素进行收集。 * - * @param supplier 供应商 + * @param supplier 供应商 * @param accumulator 累加器 - * @param combiner 组合器 - * @param 收集结果类型 + * @param combiner 组合器 + * @param 收集结果类型 * @return 收集结果 */ @Override @@ -1150,8 +567,8 @@ public class SuperStream implements Stream { * 使用指定的收集器对流中的元素进行收集。 * * @param collector 收集器 - * @param 收集结果类型 - * @param 收集器中间结果类型 + * @param 收集结果类型 + * @param 收集器中间结果类型 * @return 收集结果 */ @Override @@ -1244,102 +661,6 @@ public class SuperStream implements Stream { return stream.findAny(); } - /** - * 创建一个 SuperStream 构建器。 - * - * @param 元素类型 - * @return 构建器 - */ - public static Builder builder() { - return new Builder() { - private final List list = new ArrayList<>(); - - @Override - public void accept(T t) { - list.add(t); - } - - @Override - public @NotNull SuperStream build() { - return new SuperStream<>(list.stream()); - } - }; - } - - /** - * 创建一个空的 SuperStream 实例。 - * - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream empty() { - return new SuperStream<>(Stream.empty()); - } - - /** - * 创建一个包含单个元素的 SuperStream 实例。 - * - * @param t 元素 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream of(T t) { - return new SuperStream<>(Stream.of(t)); - } - - /** - * 创建一个包含多个元素的 SuperStream 实例。 - * - * @param values 元素数组 - * @param 元素类型 - * @return SuperStream 实例 - */ - @SafeVarargs - public static @NotNull SuperStream of(T... values) { - return new SuperStream<>(Stream.of(values)); - } - - /** - * 创建一个无限流，使用指定的种子和函数生成元素。 - * - * @param seed 种子 - * @param f 函数 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream iterate( - T seed, - UnaryOperator f - ) { - return new SuperStream<>(Stream.iterate(seed, f)); - } - - /** - * 创建一个无限流，使用指定的供应商生成元素。 - * - * @param s 供应商 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream generate(Supplier s) { - return new SuperStream<>(Stream.generate(s)); - } - - /** - * 连接两个流。 - * - * @param a 第一个流 - * @param b 第二个流 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream concat( - @NotNull Stream a, - @NotNull Stream b - ) { - return new SuperStream<>(Stream.concat(a, b)); - } - /** * 返回流的迭代器。 * @@ -1408,4 +729,737 @@ public class SuperStream implements Stream { public void close() { stream.close(); } + + public Optional findLast() { + if (isEmpty()) { + return Optional.empty(); + } + val l = Lists.toList(stream); + return Optional.of(l.get(l.size() - 1)); + } + + public T getFirst() { + return findFirst().orElse(null); + } + + public T getLast() { + return findLast().orElse(null); + } + + public T getAny() { + return findAny().orElse(null); + } + + /** + * 内部静态类 Collectors，用于提供常用的收集器实现。 + * 所有方法均是对 java.util.stream.Collectors 的封装或扩展。 + */ + public static class Collectors { + + /** + * 返回一个收集器，用于将元素映射为 long 值并求和。 + * + * @param mapper 映射函数，将元素转换为 long 值 + * @param 元素类型 + * @return 收集器 + */ + public static Collector summingLong( + @NotNull ToLongFunction mapper + ) { + return java.util.stream.Collectors.summingLong(mapper); + } + + /** + * 返回一个收集器，将元素收集到指定类型的集合中。 + * + * @param collectionFactory 集合工厂，用于创建目标集合 + * @param 元素类型 + * @param 目标集合类型 + * @return 收集器 + */ + public static > Collector< + T, + ?, + C + > toCollection(@NotNull Supplier collectionFactory) { + return java.util.stream.Collectors.toCollection(collectionFactory); + } + + /** + * 返回一个收集器，将元素收集到 List 中。 + * + * @param 元素类型 + * @return 收集器 + */ + public static Collector> toList() { + return java.util.stream.Collectors.toList(); + } + + /** + * 返回一个收集器，将元素收集到 Set 中。 + * + * @param 元素类型 + * @return 收集器 + */ + public static Collector> toSet() { + return java.util.stream.Collectors.toSet(); + } + + /** + * 返回一个收集器，将字符序列连接成字符串。 + * + * @return 收集器 + */ + public static Collector joining() { + return java.util.stream.Collectors.joining(); + } + + /** + * 返回一个收集器，将字符序列使用指定分隔符连接成字符串。 + * + * @param delimiter 分隔符 + * @return 收集器 + */ + public static Collector joining( + @NotNull CharSequence delimiter + ) { + return java.util.stream.Collectors.joining(delimiter); + } + + /** + * 返回一个收集器，将字符序列使用指定前缀、后缀和分隔符连接成字符串。 + * + * @param delimiter 分隔符 + * @param prefix 前缀 + * @param suffix 后缀 + * @return 收集器 + */ + public static Collector joining( + @NotNull CharSequence delimiter, + @NotNull CharSequence prefix, + @NotNull CharSequence suffix + ) { + return java.util.stream.Collectors.joining( + delimiter, + prefix, + suffix + ); + } + + /** + * 返回一个收集器，先对元素进行映射，再使用下游收集器进行收集。 + * + * @param mapper 映射函数 + * @param downstream 下游收集器 + * @param 输入元素类型 + * @param 映射后的元素类型 + * @param 下游收集器的中间结果类型 + * @param 最终结果类型 + * @return 收集器 + */ + public static Collector mapping( + @NotNull Function mapper, + @NotNull Collector downstream + ) { + return java.util.stream.Collectors.mapping(mapper, downstream); + } + + /** + * 返回一个收集器，在下游收集完成后应用 finisher 函数。 + * + * @param downstream 下游收集器 + * @param finisher 完成后应用的函数 + * @param 元素类型 + * @param 下游收集器的中间结果类型 + * @param 下游收集器的结果类型 + * @param 最终结果类型 + * @return 收集器 + */ + public static Collector collectingAndThen( + @NotNull Collector downstream, + @NotNull Function finisher + ) { + return java.util.stream.Collectors.collectingAndThen( + downstream, + finisher + ); + } + + /** + * 返回一个收集器，用于统计元素数量。 + * + * @param 元素类型 + * @return 收集器 + */ + public static Collector counting() { + return java.util.stream.Collectors.counting(); + } + + /** + * 返回一个收集器，找出最小元素。 + * + * @param comparator 比较器 + * @param 元素类型 + * @return 收集器 + */ + public static Collector> minBy( + @NotNull Comparator comparator + ) { + return java.util.stream.Collectors.minBy(comparator); + } + + /** + * 返回一个收集器，找出最大元素。 + * + * @param comparator 比较器 + * @param 元素类型 + * @return 收集器 + */ + public static Collector> maxBy( + @NotNull Comparator comparator + ) { + return java.util.stream.Collectors.maxBy(comparator); + } + + /** + * 返回一个收集器，将元素映射为 int 值并求和。 + * + * @param mapper 映射函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector summingInt( + @NotNull ToIntFunction mapper + ) { + return java.util.stream.Collectors.summingInt(mapper); + } + + /** + * 返回一个收集器，将元素映射为 double 值并求和。 + * + * @param mapper 映射函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector summingDouble( + @NotNull ToDoubleFunction mapper + ) { + return java.util.stream.Collectors.summingDouble(mapper); + } + + /** + * 返回一个收集器，计算元素映射为 int 值的平均值。 + * + * @param mapper 映射函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector averagingInt( + @NotNull ToIntFunction mapper + ) { + return java.util.stream.Collectors.averagingInt(mapper); + } + + /** + * 返回一个收集器，计算元素映射为 long 值的平均值。 + * + * @param mapper 映射函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector averagingLong( + @NotNull ToLongFunction mapper + ) { + return java.util.stream.Collectors.averagingLong(mapper); + } + + /** + * 返回一个收集器，计算元素映射为 double 值的平均值。 + * + * @param mapper 映射函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector averagingDouble( + @NotNull ToDoubleFunction mapper + ) { + return java.util.stream.Collectors.averagingDouble(mapper); + } + + /** + * 返回一个收集器，使用指定的初始值和二元操作符进行归约。 + * + * @param identity 初始值 + * @param op 二元操作符 + * @param 元素类型 + * @return 收集器 + */ + public static Collector reducing( + T identity, + @NotNull BinaryOperator op + ) { + return java.util.stream.Collectors.reducing(identity, op); + } + + /** + * 返回一个收集器，使用指定的二元操作符进行归约。 + * + * @param op 二元操作符 + * @param 元素类型 + * @return 收集器 + */ + public static Collector> reducing( + @NotNull BinaryOperator op + ) { + return java.util.stream.Collectors.reducing(op); + } + + /** + * 返回一个收集器，先对元素进行映射，再使用指定的初始值和二元操作符进行归约。 + * + * @param identity 初始值 + * @param mapper 映射函数 + * @param op 二元操作符 + * @param 元素类型 + * @param 映射后的元素类型 + * @return 收集器 + */ + public static Collector reducing( + U identity, + @NotNull Function mapper, + @NotNull BinaryOperator op + ) { + return java.util.stream.Collectors.reducing(identity, mapper, op); + } + + /** + * 返回一个收集器，按分类器对元素进行分组。 + * + * @param classifier 分类器函数 + * @param 元素类型 + * @param 分类键类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull Map> + > groupingBy(@NotNull Function classifier) { + return java.util.stream.Collectors.groupingBy(classifier); + } + + /** + * 返回一个收集器，按分类器对元素进行分组，并使用下游收集器处理每个组。 + * + * @param classifier 分类器函数 + * @param downstream 下游收集器 + * @param 元素类型 + * @param 分类键类型 + * @param 下游收集器的中间结果类型 + * @param 下游收集器的结果类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull Map + > groupingBy( + @NotNull Function classifier, + @NotNull Collector downstream + ) { + return java.util.stream.Collectors.groupingBy( + classifier, + downstream + ); + } + + /** + * 返回一个收集器，按分类器对元素进行分组，并使用指定的 Map 工厂和下游收集器。 + * + * @param classifier 分类器函数 + * @param mapFactory Map 工厂 + * @param downstream 下游收集器 + * @param 元素类型 + * @param 分类键类型 + * @param 下游收集器的结果类型 + * @param 下游收集器的中间结果类型 + * @param Map 类型 + * @return 收集器 + */ + public static > Collector< + T, + ?, + M + > groupingBy( + @NotNull Function classifier, + @NotNull Supplier mapFactory, + @NotNull Collector downstream + ) { + return java.util.stream.Collectors.groupingBy( + classifier, + mapFactory, + downstream + ); + } + + /** + * 返回一个并发收集器，按分类器对元素进行分组。 + * + * @param classifier 分类器函数 + * @param 元素类型 + * @param 分类键类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull ConcurrentMap> + > groupingByConcurrent( + @NotNull Function classifier + ) { + return java.util.stream.Collectors.groupingByConcurrent(classifier); + } + + /** + * 返回一个并发收集器，按分类器对元素进行分组，并使用下游收集器处理每个组。 + * + * @param classifier 分类器函数 + * @param downstream 下游收集器 + * @param 元素类型 + * @param 分类键类型 + * @param 下游收集器的中间结果类型 + * @param 下游收集器的结果类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull ConcurrentMap + > groupingByConcurrent( + @NotNull Function classifier, + @NotNull Collector downstream + ) { + return java.util.stream.Collectors.groupingByConcurrent( + classifier, + downstream + ); + } + + /** + * 返回一个并发收集器，按分类器对元素进行分组，并使用指定的 Map 工厂和下游收集器。 + * + * @param classifier 分类器函数 + * @param mapFactory Map 工厂 + * @param downstream 下游收集器 + * @param 元素类型 + * @param 分类键类型 + * @param 下游收集器的结果类型 + * @param 下游收集器的中间结果类型 + * @param Map 类型 + * @return 收集器 + */ + public static > Collector< + T, + ?, + M + > groupingByConcurrent( + @NotNull Function classifier, + @NotNull Supplier mapFactory, + @NotNull Collector downstream + ) { + return java.util.stream.Collectors.groupingByConcurrent( + classifier, + mapFactory, + downstream + ); + } + + /** + * 返回一个收集器，按谓词对元素进行分区。 + * + * @param predicate 谓词函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull Map<@NotNull Boolean, @NotNull List> + > partitioningBy(@NotNull Predicate predicate) { + return java.util.stream.Collectors.partitioningBy(predicate); + } + + /** + * 返回一个收集器，按谓词对元素进行分区，并使用下游收集器处理每个分区。 + * + * @param predicate 谓词函数 + * @param downstream 下游收集器 + * @param 元素类型 + * @param 下游收集器的结果类型 + * @param 下游收集器的中间结果类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull Map<@NotNull Boolean, D> + > partitioningBy( + @NotNull Predicate predicate, + @NotNull Collector downstream + ) { + return java.util.stream.Collectors.partitioningBy( + predicate, + downstream + ); + } + + /** + * 返回一个收集器，将元素转换为 Map。 + * + * @param keyMapper 键映射函数 + * @param valueMapper 值映射函数 + * @param 元素类型 + * @param 键类型 + * @param 值类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull Map + > toMap( + @NotNull Function keyMapper, + @NotNull Function valueMapper + ) { + return java.util.stream.Collectors.toMap(keyMapper, valueMapper); + } + + /** + * 返回一个收集器，将元素转换为 Map，并指定合并函数。 + * + * @param keyMapper 键映射函数 + * @param valueMapper 值映射函数 + * @param mergeFunction 合并函数 + * @param 元素类型 + * @param 键类型 + * @param 值类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull Map + > toMap( + @NotNull Function keyMapper, + @NotNull Function valueMapper, + @NotNull BinaryOperator mergeFunction + ) { + return java.util.stream.Collectors.toMap( + keyMapper, + valueMapper, + mergeFunction + ); + } + + /** + * 返回一个收集器，将元素转换为 Map，并指定合并函数和 Map 工厂。 + * + * @param keyMapper 键映射函数 + * @param valueMapper 值映射函数 + * @param mergeFunction 合并函数 + * @param mapSupplier Map 工厂 + * @param 元素类型 + * @param 键类型 + * @param 值类型 + * @param Map 类型 + * @return 收集器 + */ + public static > Collector toMap( + @NotNull Function keyMapper, + @NotNull Function valueMapper, + @NotNull BinaryOperator mergeFunction, + @NotNull Supplier mapSupplier + ) { + return java.util.stream.Collectors.toMap( + keyMapper, + valueMapper, + mergeFunction, + mapSupplier + ); + } + + /** + * 返回一个并发收集器，将元素转换为 ConcurrentMap。 + * + * @param keyMapper 键映射函数 + * @param valueMapper 值映射函数 + * @param 元素类型 + * @param 键类型 + * @param 值类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull ConcurrentMap + > toConcurrentMap( + @NotNull Function keyMapper, + @NotNull Function valueMapper + ) { + return java.util.stream.Collectors.toConcurrentMap( + keyMapper, + valueMapper + ); + } + + /** + * 返回一个并发收集器，将元素转换为 ConcurrentMap，并指定合并函数。 + * + * @param keyMapper 键映射函数 + * @param valueMapper 值映射函数 + * @param mergeFunction 合并函数 + * @param 元素类型 + * @param 键类型 + * @param 值类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull ConcurrentMap + > toConcurrentMap( + @NotNull Function keyMapper, + @NotNull Function valueMapper, + @NotNull BinaryOperator mergeFunction + ) { + return java.util.stream.Collectors.toConcurrentMap( + keyMapper, + valueMapper, + mergeFunction + ); + } + + /** + * 返回一个并发收集器，将元素转换为 ConcurrentMap，并指定合并函数和 Map 工厂。 + * + * @param keyMapper 键映射函数 + * @param valueMapper 值映射函数 + * @param mergeFunction 合并函数 + * @param mapSupplier Map 工厂 + * @param 元素类型 + * @param 键类型 + * @param 值类型 + * @param Map 类型 + * @return 收集器 + */ + public static > Collector< + T, + ?, + M + > toConcurrentMap( + @NotNull Function keyMapper, + @NotNull Function valueMapper, + @NotNull BinaryOperator mergeFunction, + @NotNull Supplier mapSupplier + ) { + return java.util.stream.Collectors.toConcurrentMap( + keyMapper, + valueMapper, + mergeFunction, + mapSupplier + ); + } + + /** + * 返回一个收集器，计算元素映射为 int 值的统计信息。 + * + * @param mapper 映射函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull IntSummaryStatistics + > summarizingInt(@NotNull ToIntFunction mapper) { + return java.util.stream.Collectors.summarizingInt(mapper); + } + + /** + * 返回一个收集器，计算元素映射为 long 值的统计信息。 + * + * @param mapper 映射函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull LongSummaryStatistics + > summarizingLong(@NotNull ToLongFunction mapper) { + return java.util.stream.Collectors.summarizingLong(mapper); + } + + /** + * 返回一个收集器，计算元素映射为 double 值的统计信息。 + * + * @param mapper 映射函数 + * @param 元素类型 + * @return 收集器 + */ + public static Collector< + T, + ?, + @NotNull DoubleSummaryStatistics + > summarizingDouble(@NotNull ToDoubleFunction mapper) { + return java.util.stream.Collectors.summarizingDouble(mapper); + } + + /** + * 返回当前元素本身。 + * + * @param t 元素 + * @param 元素类型 + * @return 元素本身 + */ + public static T getThis(T t) { + return t; + } + + /** + * 返回一个收集器，将元素收集到 List 中。 + * + * @param 元素类型 + * @return 收集器 + */ + public static , K, V> Collector< + T, + ?, + @NotNull Map + > toEntryMap() { + return toMap(Map.Entry::getKey, Map.Entry::getValue); + } + + public static , K> Collector< + T, + ?, + @NotNull Map + > toMap() { + return toMap(Getable::get, Collectors::getThis); + } + + /** + * 返回一个收集器，将元素转换为 Map，键由 keyMapper 生成，值为元素本身。 + * + * @param keyMapper 键映射函数 + * @param 元素类型 + * @param 键类型 + * @return 收集器 + */ + public static Collector> toMap( + @NotNull Function keyMapper + ) { + return Collectors.toMap(keyMapper, Collectors::getThis); + } + } } diff --git a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java new file mode 100644 index 0000000..6dd30db --- /dev/null +++ b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java @@ -0,0 +1,9 @@ +package com.mingliqiye.utils.stream.interfaces; + +public interface GetIdable extends Getable { + T getId(); + + default T get() { + return getId(); + } +} diff --git a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java new file mode 100644 index 0000000..b1153cc --- /dev/null +++ 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 getKey(); + + default T get() { + return getKey(); + } +} diff --git a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java new file mode 100644 index 0000000..e785ded --- /dev/null +++ b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java @@ -0,0 +1,9 @@ +package com.mingliqiye.utils.stream.interfaces; + +public interface GetNameable extends Getable { + T getName(); + + default T get() { + return getName(); + } +} diff --git a/src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java b/src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java new file mode 100644 index 0000000..72d4d13 --- /dev/null +++ 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 get(); +} diff --git a/src/main/java/com/mingliqiye/utils/string/StringUtil.java b/src/main/java/com/mingliqiye/utils/string/StringUtil.java index 6868c6d..46a655a 100644 --- 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; diff --git a/src/main/java/com/mingliqiye/utils/time/DateTime.java b/src/main/java/com/mingliqiye/utils/time/DateTime.java index eba0753..745350f 100644 --- 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 等类型的互转。 + *
+ * 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 实例。 * diff --git a/src/main/java/com/mingliqiye/utils/time/serialization/Jackson.java b/src/main/java/com/mingliqiye/utils/time/serialization/Jackson.java index 568c849..d038ffc 100644 --- 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); }