minglipro/mingli-utils
minglipro/mingli-utils
1
1
Fork 0
generated from mingliqiye/lib-tem
Code Issues Pull Requests Packages Projects Releases 23 Wiki Activity

refactor(utils): 重构工具类并添加新功能
All checks were successful
Gitea Actions Build / Build (push) Successful in 1m1s

Browse Source 
- 重构了 AutoConfiguration 类，更新了组件扫描路径
- 优化了 Collection 类中的 getOrDefault 方法，增加了对非 List 集合的支持- 添加了 DateTime 类的高精度时间处理功能
- 新增了 DateTimeToStringConverter 类，用于将 DateTime 转换为字符串
- 更新了 ForEach 类中的遍历方法，提高了代码可读性和性能
This commit is contained in:
Armamem0t 2025-09-11 09:46:03 +08:00
parent bbafa86872
commit 1a9553b55d
Signed by: minglipro
GPG Key ID: 5F355A77B22AA93B
22 changed files with 2099 additions and 1718 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gradle.properties
View File

@ -22,4 +22,4 @@
JDKVERSIONS=1.8
GROUPSID=com.mingliqiye.utils
ARTIFACTID=mingli-utils
VERSIONS=3.0.4
VERSIONS=3.0.6

3
package.json
View File

@ -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",

9
src/main/java/com/mingliqiye/utils/Main.java
View File

@ -22,21 +22,12 @@
package com.mingliqiye.utils;
import com.mingliqiye.utils.collection.Lists;
import com.mingliqiye.utils.collection.Maps;
import com.mingliqiye.utils.springboot.autoconfigure.AutoConfiguration;
import com.mingliqiye.utils.stream.SuperStream;
import java.io.IOException;
import java.util.List;
import java.util.Map;
public class Main {
public static void main(String[] args) throws IOException {
AutoConfiguration.printBanner();
Map<String, String> map = Maps.of("1", "2", "3", "4");
SuperStream.of(map).entryToMap();
}
}

3
src/main/java/com/mingliqiye/utils/bean/springboot/SpringBeanUtil.java
View File

@ -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
*/

19
src/main/java/com/mingliqiye/utils/collection/Collection.java
View File

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

119
src/main/java/com/mingliqiye/utils/collection/ForEach.java
View File

@ -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;
@ -54,7 +53,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param <T> 集合中元素的类型
*/
public static <T> void forEach(Collection<T> collection, P2Function<? super T, Integer> action) {
public static <T> void forEach(
Collection<T> collection,
P2Function<? super T, Integer> action
) {
// 参数校验：如果集合或操作为空，则直接返回
if (collection == null || action == null) {
return;
@ -94,7 +96,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，只接收元素值作为参数
* @param <T> 集合中元素的类型
*/
public static <T> void forEach(Collection<T> collection, P1Function<? super T> action) {
public static <T> void forEach(
Collection<T> collection,
P1Function<? super T> action
) {
// 参数校验：如果集合或操作为空，则直接返回
if (collection == null || action == null) {
return;
@ -124,7 +129,10 @@ public class ForEach {
* @param <K> 映射中键的类型
* @param <V> 映射中值的类型
*/
public static <K, V> void forEach(Map<K, V> map, P3Function<? super K, ? super V, Integer> action) {
public static <K, V> void forEach(
Map<K, V> map,
P3Function<? super K, ? super V, Integer> action
) {
// 参数校验：如果映射或操作为空，则直接返回
if (map == null || action == null) {
return;
@ -165,7 +173,10 @@ public class ForEach {
* @param <K> 映射中键的类型
* @param <V> 映射中值的类型
*/
public static <K, V> void forEach(Map<K, V> map, P2Function<? super K, ? super V> action) {
public static <K, V> void forEach(
Map<K, V> map,
P2Function<? super K, ? super V> action
) {
// 参数校验：如果映射或操作为空，则直接返回
if (map == null || action == null) {
return;
@ -179,7 +190,7 @@ public class ForEach {
}
// 如果是 ConcurrentMap 或 LinkedHashMap，使用其内置的 forEach 方法
else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
forEach(map.entrySet(), (i) -> action.call(i.getKey(), i.getValue()));
forEach(map.entrySet(), i -> action.call(i.getKey(), i.getValue()));
}
// 遍历其他类型映射的条目集合
else {
@ -196,7 +207,10 @@ public class ForEach {
* @param objects 要遍历的可变参数数组
* @param <T> 数组中元素的类型
*/
public static <T> void forEach(P2Function<? super T, Integer> action, T... objects) {
public static <T> void forEach(
P2Function<? super T, Integer> action,
T... objects
) {
forEach(Lists.newArrayList(objects), action);
}
@ -207,7 +221,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param <T> 数组中元素的类型
*/
public static <T> void forEach(T[] objects, P2Function<? super T, Integer> action) {
public static <T> void forEach(
T[] objects,
P2Function<? super T, Integer> action
) {
forEach(action, objects);
}
@ -239,7 +256,10 @@ public class ForEach {
* @param objects 要遍历的整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
public static void forEach(int[] objects, P2Function<Integer, Integer> action) {
public static void forEach(
int[] objects,
P2Function<Integer, Integer> action
) {
forEach(action, objects);
}
@ -249,7 +269,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param objects 要遍历的整型可变参数数组
*/
private static void forEach(P2Function<Integer, Integer> action, int... objects) {
private static void forEach(
P2Function<Integer, Integer> action,
int... objects
) {
forEach(objects, action);
}
@ -269,7 +292,10 @@ public class ForEach {
* @param objects 要遍历的字节数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
public static void forEach(byte[] objects, P2Function<Byte, Integer> action) {
public static void forEach(
byte[] objects,
P2Function<Byte, Integer> action
) {
forEach(Lists.toList(objects), action);
}
@ -279,7 +305,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param objects 要遍历的字节可变参数数组
*/
private static void forEach(P2Function<Byte, Integer> action, byte... objects) {
private static void forEach(
P2Function<Byte, Integer> action,
byte... objects
) {
forEach(objects, action);
}
@ -299,7 +328,10 @@ public class ForEach {
* @param objects 要遍历的短整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
public static void forEach(short[] objects, P2Function<Short, Integer> action) {
public static void forEach(
short[] objects,
P2Function<Short, Integer> action
) {
forEach(Lists.toList(objects), action);
}
@ -309,7 +341,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param objects 要遍历的短整型可变参数数组
*/
private static void forEach(P2Function<Short, Integer> action, short... objects) {
private static void forEach(
P2Function<Short, Integer> action,
short... objects
) {
forEach(objects, action);
}
@ -329,7 +364,10 @@ public class ForEach {
* @param objects 要遍历的长整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
public static void forEach(long[] objects, P2Function<Long, Integer> action) {
public static void forEach(
long[] objects,
P2Function<Long, Integer> action
) {
forEach(action, objects);
}
@ -339,7 +377,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param objects 要遍历的长整型可变参数数组
*/
private static void forEach(P2Function<Long, Integer> action, long... objects) {
private static void forEach(
P2Function<Long, Integer> action,
long... objects
) {
forEach(Lists.toList(objects), action);
}
@ -359,7 +400,10 @@ public class ForEach {
* @param objects 要遍历的浮点数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
public static void forEach(float[] objects, P2Function<Float, Integer> action) {
public static void forEach(
float[] objects,
P2Function<Float, Integer> action
) {
forEach(action, objects);
}
@ -369,7 +413,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param objects 要遍历的浮点可变参数数组
*/
private static void forEach(P2Function<Float, Integer> action, float... objects) {
private static void forEach(
P2Function<Float, Integer> action,
float... objects
) {
forEach(Lists.toList(objects), action);
}
@ -389,7 +436,10 @@ public class ForEach {
* @param objects 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
public static void forEach(double[] objects, P2Function<Double, Integer> action) {
public static void forEach(
double[] objects,
P2Function<Double, Integer> action
) {
forEach(action, objects);
}
@ -399,7 +449,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param objects 要遍历的双精度浮点可变参数数组
*/
private static void forEach(P2Function<Double, Integer> action, double... objects) {
private static void forEach(
P2Function<Double, Integer> action,
double... objects
) {
forEach(Lists.toList(objects), action);
}
@ -419,7 +472,10 @@ public class ForEach {
* @param objects 要遍历的字符数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
public static void forEach(char[] objects, P2Function<Character, Integer> action) {
public static void forEach(
char[] objects,
P2Function<Character, Integer> action
) {
forEach(action, objects);
}
@ -429,7 +485,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param objects 要遍历的字符可变参数数组
*/
private static void forEach(P2Function<Character, Integer> action, char... objects) {
private static void forEach(
P2Function<Character, Integer> action,
char... objects
) {
forEach(Lists.toList(objects), action);
}
@ -449,7 +508,10 @@ public class ForEach {
* @param objects 要遍历的布尔数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
*/
public static void forEach(boolean[] objects, P2Function<Character, Integer> action) {
public static void forEach(
boolean[] objects,
P2Function<Character, Integer> action
) {
forEach(objects, action);
}
@ -459,7 +521,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数
* @param objects 要遍历的布尔可变参数数组
*/
private static void forEach(P2Function<Boolean, Integer> action, boolean... objects) {
private static void forEach(
P2Function<Boolean, Integer> action,
boolean... objects
) {
forEach(Lists.toList(objects), action);
}
@ -469,8 +534,10 @@ public class ForEach {
* @param action 要对每个元素执行的操作，只接收元素值作为参数
* @param objects 要遍历的布尔可变参数数组
*/
private static void forEach(P1Function<Boolean> action, boolean... objects) {
private static void forEach(
P1Function<Boolean> action,
boolean... objects
) {
forEach(Lists.toList(objects), action);
}
}

176
src/main/java/com/mingliqiye/utils/collection/ForEachBreaked.java
View File

@ -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;
@ -56,7 +55,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param <T> 集合中元素的类型
*/
public static <T> void forEach(Collection<T> collection, P2RFunction<? super T, Integer, Boolean> action) {
public static <T> void forEach(
Collection<T> collection,
P2RFunction<? super T, Integer, Boolean> action
) {
// 参数校验：如果集合或操作为空，则直接返回
if (collection == null || action == null) {
return;
@ -97,7 +99,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param <T> 集合中元素的类型
*/
public static <T> void forEach(Collection<T> collection, P1RFunction<? super T, Boolean> action) {
public static <T> void forEach(
Collection<T> collection,
P1RFunction<? super T, Boolean> action
) {
// 参数校验：如果集合或操作为空，则直接返回
if (collection == null || action == null) {
return;
@ -128,7 +133,10 @@ public class ForEachBreaked {
* @param <K> 映射中键的类型
* @param <V> 映射中值的类型
*/
public static <K, V> void forEach(Map<K, V> map, P3RFunction<? super K, ? super V, Integer, Boolean> action) {
public static <K, V> void forEach(
Map<K, V> map,
P3RFunction<? super K, ? super V, Integer, Boolean> action
) {
// 参数校验：如果映射或操作为空，则直接返回
if (map == null || action == null) {
return;
@ -138,7 +146,9 @@ public class ForEachBreaked {
if (map instanceof TreeMap) {
int index = 0;
for (Map.Entry<K, V> entry : map.entrySet()) {
if (action.call(entry.getKey(), entry.getValue(), index)) return;
if (
action.call(entry.getKey(), entry.getValue(), index)
) return;
index++;
}
}
@ -146,7 +156,9 @@ public class ForEachBreaked {
else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
int index = 0;
for (Map.Entry<K, V> entry : map.entrySet()) {
if (action.call(entry.getKey(), entry.getValue(), index)) return;
if (
action.call(entry.getKey(), entry.getValue(), index)
) return;
index++;
}
}
@ -154,7 +166,9 @@ public class ForEachBreaked {
else {
int index = 0;
for (Map.Entry<K, V> entry : map.entrySet()) {
if (action.call(entry.getKey(), entry.getValue(), index)) return;
if (
action.call(entry.getKey(), entry.getValue(), index)
) return;
index++;
}
}
@ -170,7 +184,10 @@ public class ForEachBreaked {
* @param <K> 映射中键的类型
* @param <V> 映射中值的类型
*/
public static <K, V> void forEach(Map<K, V> map, P2RFunction<? super K, ? super V, Boolean> action) {
public static <K, V> void forEach(
Map<K, V> map,
P2RFunction<? super K, ? super V, Boolean> action
) {
// 参数校验：如果映射或操作为空，则直接返回
if (map == null || action == null) {
return;
@ -184,7 +201,7 @@ public class ForEachBreaked {
}
// 如果是 ConcurrentMap 或 LinkedHashMap，使用其内置的 forEach 方法
else if (map instanceof ConcurrentMap || map instanceof LinkedHashMap) {
forEach(map.entrySet(), (i) -> {
forEach(map.entrySet(), i -> {
if (action.call(i.getKey(), i.getValue())) return true;
return false;
});
@ -205,7 +222,10 @@ public class ForEachBreaked {
* @param objects 要遍历的可变参数数组
* @param <T> 数组中元素的类型
*/
public static <T> void forEach(P2RFunction<? super T, Integer, Boolean> action, T... objects) {
public static <T> void forEach(
P2RFunction<? super T, Integer, Boolean> action,
T... objects
) {
forEach(Lists.newArrayList(objects), action);
}
@ -217,7 +237,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param <T> 数组中元素的类型
*/
public static <T> void forEach(T[] objects, P2RFunction<? super T, Integer, Boolean> action) {
public static <T> void forEach(
T[] objects,
P2RFunction<? super T, Integer, Boolean> action
) {
forEach(action, objects);
}
@ -229,7 +252,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param <T> 数组中元素的类型
*/
public static <T> void forEach(T[] objects, P1RFunction<? super T, Boolean> action) {
public static <T> void forEach(
T[] objects,
P1RFunction<? super T, Boolean> action
) {
forEach(action, objects);
}
@ -241,7 +267,10 @@ public class ForEachBreaked {
* @param objects 要遍历的可变参数数组
* @param <T> 数组中元素的类型
*/
public static <T> void forEach(P1RFunction<? super T, Boolean> action, T... objects) {
public static <T> void forEach(
P1RFunction<? super T, Boolean> action,
T... objects
) {
forEach(Lists.toList(objects), (t, i) -> {
if (action.call(t)) return true;
return false;
@ -255,7 +284,10 @@ public class ForEachBreaked {
* @param objects 要遍历的整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
*/
public static void forEach(int[] objects, P2RFunction<Integer, Integer, Boolean> action) {
public static void forEach(
int[] objects,
P2RFunction<Integer, Integer, Boolean> action
) {
forEach(action, objects);
}
@ -266,7 +298,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的整型可变参数数组
*/
private static void forEach(P2RFunction<Integer, Integer, Boolean> action, int... objects) {
private static void forEach(
P2RFunction<Integer, Integer, Boolean> action,
int... objects
) {
forEach(objects, action);
}
@ -277,7 +312,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的整型可变参数数组
*/
private static void forEach(P1RFunction<Integer, Boolean> action, int... objects) {
private static void forEach(
P1RFunction<Integer, Boolean> action,
int... objects
) {
forEach(Lists.toList(objects), action);
}
@ -288,7 +326,10 @@ public class ForEachBreaked {
* @param objects 要遍历的字节数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
*/
public static void forEach(byte[] objects, P2RFunction<Byte, Integer, Boolean> action) {
public static void forEach(
byte[] objects,
P2RFunction<Byte, Integer, Boolean> action
) {
forEach(Lists.toList(objects), action);
}
@ -299,7 +340,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的字节可变参数数组
*/
private static void forEach(P2RFunction<Byte, Integer, Boolean> action, byte... objects) {
private static void forEach(
P2RFunction<Byte, Integer, Boolean> action,
byte... objects
) {
forEach(objects, action);
}
@ -310,7 +354,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的字节可变参数数组
*/
private static void forEach(P1RFunction<Byte, Boolean> action, byte... objects) {
private static void forEach(
P1RFunction<Byte, Boolean> action,
byte... objects
) {
forEach(Lists.toList(objects), action);
}
@ -321,7 +368,10 @@ public class ForEachBreaked {
* @param objects 要遍历的短整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
*/
public static void forEach(short[] objects, P2RFunction<Short, Integer, Boolean> action) {
public static void forEach(
short[] objects,
P2RFunction<Short, Integer, Boolean> action
) {
forEach(Lists.toList(objects), action);
}
@ -332,7 +382,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的短整型可变参数数组
*/
private static void forEach(P2RFunction<Short, Integer, Boolean> action, short... objects) {
private static void forEach(
P2RFunction<Short, Integer, Boolean> action,
short... objects
) {
forEach(objects, action);
}
@ -343,7 +396,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的短整型可变参数数组
*/
private static void forEach(P1RFunction<Short, Boolean> action, short... objects) {
private static void forEach(
P1RFunction<Short, Boolean> action,
short... objects
) {
forEach(Lists.toList(objects), action);
}
@ -354,7 +410,10 @@ public class ForEachBreaked {
* @param objects 要遍历的长整型数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
*/
public static void forEach(long[] objects, P2RFunction<Long, Integer, Boolean> action) {
public static void forEach(
long[] objects,
P2RFunction<Long, Integer, Boolean> action
) {
forEach(action, objects);
}
@ -365,7 +424,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的长整型可变参数数组
*/
private static void forEach(P2RFunction<Long, Integer, Boolean> action, long... objects) {
private static void forEach(
P2RFunction<Long, Integer, Boolean> action,
long... objects
) {
forEach(Lists.toList(objects), action);
}
@ -376,7 +438,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的长整型可变参数数组
*/
private static void forEach(P1RFunction<Long, Boolean> action, long... objects) {
private static void forEach(
P1RFunction<Long, Boolean> action,
long... objects
) {
forEach(Lists.toList(objects), action);
}
@ -387,7 +452,10 @@ public class ForEachBreaked {
* @param objects 要遍历的浮点数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
*/
public static void forEach(float[] objects, P2RFunction<Float, Integer, Boolean> action) {
public static void forEach(
float[] objects,
P2RFunction<Float, Integer, Boolean> action
) {
forEach(action, objects);
}
@ -398,7 +466,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的浮点可变参数数组
*/
private static void forEach(P2RFunction<Float, Integer, Boolean> action, float... objects) {
private static void forEach(
P2RFunction<Float, Integer, Boolean> action,
float... objects
) {
forEach(Lists.toList(objects), action);
}
@ -409,7 +480,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的浮点可变参数数组
*/
private static void forEach(P1RFunction<Float, Boolean> action, float... objects) {
private static void forEach(
P1RFunction<Float, Boolean> action,
float... objects
) {
forEach(Lists.toList(objects), action);
}
@ -420,7 +494,10 @@ public class ForEachBreaked {
* @param objects 要遍历的双精度浮点数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
*/
public static void forEach(double[] objects, P2RFunction<Double, Integer, Boolean> action) {
public static void forEach(
double[] objects,
P2RFunction<Double, Integer, Boolean> action
) {
forEach(action, objects);
}
@ -431,7 +508,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的双精度浮点可变参数数组
*/
private static void forEach(P2RFunction<Double, Integer, Boolean> action, double... objects) {
private static void forEach(
P2RFunction<Double, Integer, Boolean> action,
double... objects
) {
forEach(Lists.toList(objects), action);
}
@ -442,7 +522,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的双精度浮点可变参数数组
*/
private static void forEach(P1RFunction<Double, Boolean> action, double... objects) {
private static void forEach(
P1RFunction<Double, Boolean> action,
double... objects
) {
forEach(Lists.toList(objects), action);
}
@ -453,7 +536,10 @@ public class ForEachBreaked {
* @param objects 要遍历的字符数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
*/
public static void forEach(char[] objects, P2RFunction<Character, Integer, Boolean> action) {
public static void forEach(
char[] objects,
P2RFunction<Character, Integer, Boolean> action
) {
forEach(action, objects);
}
@ -464,7 +550,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的字符可变参数数组
*/
private static void forEach(P2RFunction<Character, Integer, Boolean> action, char... objects) {
private static void forEach(
P2RFunction<Character, Integer, Boolean> action,
char... objects
) {
forEach(Lists.toList(objects), action);
}
@ -475,7 +564,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的字符可变参数数组
*/
private static void forEach(P1RFunction<Character, Boolean> action, char... objects) {
private static void forEach(
P1RFunction<Character, Boolean> action,
char... objects
) {
forEach(Lists.toList(objects), action);
}
@ -486,7 +578,10 @@ public class ForEachBreaked {
* @param objects 要遍历的布尔数组
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
*/
public static void forEach(boolean[] objects, P2RFunction<Character, Integer, Boolean> action) {
public static void forEach(
boolean[] objects,
P2RFunction<Character, Integer, Boolean> action
) {
forEach(objects, action);
}
@ -497,7 +592,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，接收元素值和索引作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的布尔可变参数数组
*/
private static void forEach(P2RFunction<Boolean, Integer, Boolean> action, boolean... objects) {
private static void forEach(
P2RFunction<Boolean, Integer, Boolean> action,
boolean... objects
) {
forEach(Lists.toList(objects), action);
}
@ -508,8 +606,10 @@ public class ForEachBreaked {
* @param action 要对每个元素执行的操作，只接收元素值作为参数，返回 Boolean 值决定是否继续遍历
* @param objects 要遍历的布尔可变参数数组
*/
private static void forEach(P1RFunction<Boolean, Boolean> action, boolean... objects) {
private static void forEach(
P1RFunction<Boolean, Boolean> action,
boolean... objects
) {
forEach(Lists.toList(objects), action);
}
}

30
src/main/java/com/mingliqiye/utils/collection/Lists.java
View File

@ -22,7 +22,14 @@
package com.mingliqiye.utils.collection;
import static com.mingliqiye.utils.collection.Collection.findFirst;
import com.github.f4b6a3.uuid.util.internal.RandomUtil;
import com.mingliqiye.utils.random.RandomInt;
import java.util.*;
import java.util.Collection;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@ -299,6 +306,13 @@ public class Lists {
return ts == null ? null : new ArrayList<>(Arrays.asList(ts));
}
@NotNull
public static <T> List<T> toList(Stream<T> ts) {
return ts == null
? newArrayList()
: new ArrayList<>(ts.collect(Collectors.toList()));
}
/**
* 将int数组转换为Integer列表
*
@ -442,4 +456,20 @@ public class Lists {
}
return list;
}
public <T> T getFirst(Collection<T> collectors) {
return com.mingliqiye.utils.collection.Collection.getFirst(collectors);
}
public <T> T getLast(Collection<T> collectors) {
return com.mingliqiye.utils.collection.Collection.getFirst(collectors);
}
public <T> T getAny(Collection<T> collectors) {
return com.mingliqiye.utils.collection.Collection.getOrDefault(
collectors,
RandomInt.randomInt(0, collectors.size()),
null
);
}
}

7
src/main/java/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java
View File

@ -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 =

25
src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/DateTimeToStringConverter.java Normal file
View File

@ -0,0 +1,25 @@
package com.mingliqiye.utils.springboot.autoconfigure.converters;
import static com.mingliqiye.utils.time.Formatter.STANDARD_DATETIME;
import com.mingliqiye.utils.time.DateTime;
import org.jetbrains.annotations.NotNull;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
/**
* spring boot DateTime到字符串转换器
*
* @author MingliPro
* @see DateTime
*
*
*/
@Component
public class DateTimeToStringConverter implements Converter<DateTime, String> {
@Override
public String convert(@NotNull DateTime source) {
return source.format(STANDARD_DATETIME);
}
}

25
src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToDateTimeConverter.java Normal file
View File

@ -0,0 +1,25 @@
package com.mingliqiye.utils.springboot.autoconfigure.converters;
import static com.mingliqiye.utils.time.Formatter.STANDARD_DATETIME_MILLISECOUND7;
import com.mingliqiye.utils.time.DateTime;
import org.jetbrains.annotations.NotNull;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
/**
* spring boot 字符串到DateTime转换器
*
* @author MingliPro
* @see DateTime
*
*
*/
@Component
public class StringToDateTimeConverter implements Converter<String, DateTime> {
@Override
public DateTime convert(@NotNull String source) {
return DateTime.parse(source, STANDARD_DATETIME_MILLISECOUND7, true);
}
}

20
src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/StringToUUIDConverter.java Normal file
View File

@ -0,0 +1,20 @@
package com.mingliqiye.utils.springboot.autoconfigure.converters;
import com.mingliqiye.utils.uuid.UUID;
import org.jetbrains.annotations.NotNull;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
/**
* spring boot 字符串到UUID转换器
* @see UUID
* @author MingliPro
*/
@Component
public class StringToUUIDConverter implements Converter<String, UUID> {
@Override
public UUID convert(@NotNull String source) {
return UUID.of(source);
}
}

20
src/main/java/com/mingliqiye/utils/springboot/autoconfigure/converters/UUIDToStringConverter.java Normal file
View File

@ -0,0 +1,20 @@
package com.mingliqiye.utils.springboot.autoconfigure.converters;
import com.mingliqiye.utils.uuid.UUID;
import org.jetbrains.annotations.NotNull;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Component;
/**
* spring boot UUID到字符串转换器
* @see UUID
* @author MingliPro
*/
@Component
public class UUIDToStringConverter implements Converter<UUID, String> {
@Override
public String convert(@NotNull UUID source) {
return source.toUUIDString();
}
}

1
src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java
View File

@ -56,6 +56,7 @@ public class InputStreamUtils {
/**
* 将输入流读取为字符串<br>
* 请在外部自行关闭输入流对象 避免资源泄露
*
* @param inputStream 输入流对象，用于读取数据
* @return 输入流对应的字符串内容
* @throws IOException 当读取输入流时发生IO异常

1398
src/main/java/com/mingliqiye/utils/stream/SuperStream.java
View File

File diff suppressed because it is too large Load Diff

9
src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java Normal file
View File

@ -0,0 +1,9 @@
package com.mingliqiye.utils.stream.interfaces;
public interface GetIdable<T> extends Getable<T> {
T getId();
default T get() {
return getId();
}
}

9
src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java Normal file
View File

@ -0,0 +1,9 @@
package com.mingliqiye.utils.stream.interfaces;
public interface GetKeyable<T> {
T getKey();
default T get() {
return getKey();
}
}

9
src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java Normal file
View File

@ -0,0 +1,9 @@
package com.mingliqiye.utils.stream.interfaces;
public interface GetNameable<T> extends Getable<T> {
T getName();
default T get() {
return getName();
}
}

5
src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java Normal file
View File

@ -0,0 +1,5 @@
package com.mingliqiye.utils.stream.interfaces;
public interface Getable<T> {
T get();
}

2
src/main/java/com/mingliqiye/utils/string/StringUtil.java
View File

@ -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;

12
src/main/java/com/mingliqiye/utils/time/DateTime.java
View File

@ -23,6 +23,7 @@
package com.mingliqiye.utils.time;
import com.mingliqiye.utils.jna.time.WinKernel32;
import com.mingliqiye.utils.system.SystemUtil;
import java.io.Serializable;
import java.time.Instant;
import java.time.LocalDateTime;
@ -36,8 +37,10 @@ import lombok.var;
import org.jetbrains.annotations.NotNull;
/**
* 时间工具类，用于处理日期时间的转换、格式化等操作。
* 时间类，用于处理日期时间的转换、格式化等操作。
* 提供了多种静态方法来创建 DateTime 实例，并支持与 Date、LocalDateTime 等类型的互转。
*<br>
* windows java 1.8 及以下 使用windows Api 获取高精度时间
*
* @author MingLiPro
* @see java.time
@ -51,13 +54,12 @@ import org.jetbrains.annotations.NotNull;
@Setter
public final class DateTime implements Serializable {
private static final String version = System.getProperty("java.version");
private static final WinKernel32 WIN_KERNEL_32;
private static final long FILETIME_EPOCH_OFFSET = -116444736000000000L;
private static final long NANOS_PER_100NS = 100;
static {
if (version.startsWith("1.8")) {
if (!SystemUtil.isJdk8Plus() && SystemUtil.isWindows()) {
WIN_KERNEL_32 = WinKernel32.load();
} else {
WIN_KERNEL_32 = null;
@ -118,10 +120,6 @@ public final class DateTime implements Serializable {
return new DateTime();
}
public static void main(String[] args) {
System.out.println(DateTime.now());
}
/**
* 将 Date 对象转换为 DateTime 实例。
*

2
src/main/java/com/mingliqiye/utils/time/serialization/Jackson.java
View File

@ -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);
}