Merge branch 'dev-features'

ccoderJava · ccoderJava · commit f1e497cf7441 · 2025-06-07T22:26:14.000+08:00
diff --git a/summer-java-core/src/main/java/com/dianpoint/summer/lang/Predicates.java b/summer-java-core/src/main/java/com/dianpoint/summer/lang/Predicates.java
@@ -39,4 +39,45 @@ static <T> Predicate<T> alwaysFalse() {
     }
 
 
+    static <T> Predicate<? super T> and(Predicate<? super T>... predicates) {
+        int length = predicates == null ? 0 : predicates.length;
+        if (length == 0) {
+            return alwaysTrue();
+        }
+        if (length == 1) {
+            return predicates[0];
+        }
+        Predicate<T> andPredicate = alwaysTrue();
+        for (Predicate<? super T> predicate : predicates) {
+            andPredicate = andPredicate.and(predicate);
+        }
+        return andPredicate;
+    }
+
+    /**
+     * 输出一个逻辑或运算
+     *
+     * @param predicates {@link Predicate predicates}
+     * @param <T>        被判断的对象
+     * @return non-null
+     */
+    static <T> Predicate<? super T> or(Predicate<? super T>... predicates) {
+        int length = predicates == null ? 0 : predicates.length;
+        if (length == 0) {
+            return alwaysFalse();
+        }
+        if (length == 1) {
+            return predicates[0];
+        }
+
+        Predicate<T> orPredicate = alwaysFalse();
+
+        for (Predicate<? super T> predicate : predicates) {
+            orPredicate = orPredicate.or(predicate);
+        }
+        return orPredicate;
+
+    }
+
+
 }
diff --git a/summer-java-core/src/main/java/com/dianpoint/summer/lang/Streams.java b/summer-java-core/src/main/java/com/dianpoint/summer/lang/Streams.java
@@ -1,5 +1,16 @@
 package com.dianpoint.summer.lang;
 
+import com.dianpoint.summer.utils.SetUtils;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
 /**
  * @author: congccoder
  * @email: congccoder@gmail.com | <a href="https://github.com/ccoderJava">github-homepage</a>
@@ -8,5 +19,89 @@
 
 public interface Streams {
 
+    static <T> Stream<T> stream(T... values) {
+        return Stream.of(values);
+    }
+
+    static <T> Stream<T> stream(Iterable<T> iterable) {
+        return StreamSupport.stream(iterable.spliterator(), false);
+    }
+
+
+    static <T> Stream<T> filterStream(T[] values, Predicate<? super T> predicate) {
+        Stream<T> stream = stream(values);
+        return stream.filter(predicate);
+    }
+
+    static <T, S extends Iterable<T>> Stream<T> filterStream(S values, Predicate<? super T> predicate) {
+        return stream(values).filter(predicate);
+    }
+
+    static <T> List<T> filterList(T[] values, Predicate<? super T> predicate) {
+        return filterList(Arrays.asList(values), predicate);
+    }
+
+    static <T, S extends Iterable<T>> List<T> filterList(S values, Predicate<? super T> predicate) {
+        return filterStream(values, predicate).collect(Collectors.toList());
+    }
+
+
+    static <T, S extends Iterable<T>> Set<T> filterSet(S values, Predicate<? super T> predicate) {
+        return filterStream(values, predicate).collect(LinkedHashSet::new, Set::add, Set::addAll);
+    }
+
+    static <T> Set<T> filterSet(T[] values, Predicate<T> predicate) {
+        return filterSet(Arrays.asList(values), predicate);
+    }
+
+
+    static <T, S extends Iterable<T>> S filter(S values, Predicate<? super T> predicate) {
+        boolean isSet = SetUtils.isSet(values);
+        if (isSet) {
+            return (S) filterSet(values, predicate);
+        }
+        return (S) filterList(values, predicate);
+    }
+
+
+    //filter逻辑操作
+
+    //通用的filter过滤方法，对于集合iterable类型进行过滤处理
+    static <T, S extends Iterable<T>> S filterAll(S values, Predicate<? super T>... predicates) {
+        return filter(values, Predicates.and(predicates));
+    }
+
+    //对iterable进行逻辑and 逻辑or处理
+
+    static <T> List<T> filterAllList(T[] values, Predicate<? super T>... predicates) {
+        return filterAll(Arrays.asList(values), predicates);
+    }
+
+    static <T> Set<T> filterAllSet(T[] values, Predicate<? super T>... predicates) {
+        return filterAll(SetUtils.ofSet(values), predicates);
+    }
+
+
+    static <T, S extends Iterable<T>> S filterAny(S values, Predicate<? super T>... predicates) {
+        return filter(values, Predicates.or(predicates));
+    }
+
+    static <T> List<T> filterAnyList(T[] values, Predicate<? super T>... predicates) {
+        return filterAny(Arrays.asList(values), predicates);
+    }
+
+    static <T> Set<T> filterAnySet(T[] values, Predicate<? super T>... predicates) {
+        return filterAny(SetUtils.ofSet(values), predicates);
+    }
+
+
+    //再添加一个findFirst方法
+    static <T> T filterFirst(Iterable<T> values, Predicate<T>... predicates) {
+        return StreamSupport.stream(values.spliterator(), false)
+                .filter(Predicates.and(predicates))
+                .findFirst()
+                .orElse(null);
+    }
+
 
 }
diff --git a/summer-java-core/src/main/java/com/dianpoint/summer/lang/ThrowableConsumer.java b/summer-java-core/src/main/java/com/dianpoint/summer/lang/ThrowableConsumer.java
@@ -0,0 +1,50 @@
+package com.dianpoint.summer.lang;
+
+import com.dianpoint.summer.utils.AssertUtils;
+
+import java.util.function.BiConsumer;
+
+@FunctionalInterface
+public interface ThrowableConsumer<T> {
+
+    void accept(T t) throws Throwable;
+
+
+    /**
+     * 定义一个默认的异常处理方法，用来固定抛出一个runtimeException
+     *
+     * @param t         入参
+     * @param throwable 待抛出的异常
+     */
+    default void handleException(T t, Throwable throwable) {
+        throw new RuntimeException(throwable);
+    }
+
+    /**
+     * 默认执行逻辑，无客制化异常处理逻辑，采用默认的异常处理方法{@link #handleException(Object, Throwable)}
+     *
+     * @param t 入参
+     */
+    default void execute(T t) {
+        execute(t, this::handleException);
+    }
+
+    default void execute(T t, BiConsumer<T, Throwable> exceptionHandler) throws NullPointerException {
+        AssertUtils.assertNotNull(exceptionHandler, () -> "The 'exceptionHandler' must not be null");
+        try {
+            accept(t);
+        } catch (Throwable failure) {
+            exceptionHandler.accept(t, failure);
+        }
+    }
+
+    default void execute(T t, ThrowableConsumer<T> consumer) throws NullPointerException {
+        consumer.execute(t, this::handleException);
+    }
+
+    default void execute(T t, ThrowableConsumer<T> consumer, BiConsumer<T, Throwable> exceptionHandler)
+            throws NullPointerException {
+        AssertUtils.assertNotNull(exceptionHandler, () -> "The 'exceptionHandler' must not be null");
+        consumer.execute(t, exceptionHandler);
+    }
+}
diff --git a/summer-java-core/src/main/java/com/dianpoint/summer/lang/ThrowableFunction.java b/summer-java-core/src/main/java/com/dianpoint/summer/lang/ThrowableFunction.java
@@ -0,0 +1,60 @@
+package com.dianpoint.summer.lang;
+
+import com.dianpoint.summer.utils.AssertUtils;
+
+import java.util.function.BiFunction;
+
+/**
+ * 一个通用的抽象的处理异常的function
+ *
+ * @param <T> 入参
+ * @param <R> 结果
+ */
+@FunctionalInterface
+public interface ThrowableFunction<T, R> {
+
+    R apply(T t) throws Throwable;
+
+    default R handlerException(T t, Throwable throwable) {
+        throw new RuntimeException(throwable);
+    }
+
+    default R execute(T t, BiFunction<T, Throwable, R> exceptionHandler) {
+        R result;
+        try {
+            result = apply(t);
+        } catch (Throwable failure) {
+            result = exceptionHandler.apply(t, failure);
+        }
+        return result;
+    }
+
+    default R execute(T t) throws RuntimeException {
+        return execute(t, this::handlerException);
+    }
+
+    default <T, R> R execute(T t, ThrowableFunction<T, R> function, BiFunction<T, Throwable, R> exceptionHandler)
+            throws IllegalArgumentException {
+        AssertUtils.assertNotNull(function, "The 'function' must not be null");
+        AssertUtils.assertNotNull(exceptionHandler, "The 'exceptionHandler' must not be null");
+
+        return function.execute(t, exceptionHandler);
+    }
+
+    default <T, R> R execute(T t, ThrowableFunction<T, R> function) throws IllegalArgumentException {
+        AssertUtils.assertNotNull(function, "The 'function' must not be null");
+        return execute(t, function, function::handlerException);
+    }
+
+    default <V> ThrowableFunction<V, R> compose(ThrowableFunction<? super V, ? extends T> before) {
+        AssertUtils.assertNotNull(before, "The 'before' must not be null");
+        return (V v) -> apply(before.apply(v));
+    }
+
+    default <V> ThrowableFunction<T, V> andThen(ThrowableFunction<? super R, ? extends V> after) {
+        AssertUtils.assertNotNull(after, "The 'after' must not be null");
+        return (T t) -> after.apply(apply(t));
+    }
+
+
+}
diff --git a/summer-java-core/src/main/java/com/dianpoint/summer/utils/SetUtils.java b/summer-java-core/src/main/java/com/dianpoint/summer/utils/SetUtils.java
@@ -0,0 +1,33 @@
+package com.dianpoint.summer.utils;
+
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class SetUtils implements Utils {
+
+    protected static final float FIXED_LOAD_FACTOR = 1.00f;
+
+    public static boolean isSet(Iterable<?> elements) {
+        return elements instanceof Set;
+    }
+
+    public static <E> Set<E> of(E... elements) {
+    return ofSet(elements);
+    }
+
+    public static <E> Set<E> ofSet(E... elements) {
+        int size = elements == null ? 0 : elements.length;
+        if (size < 1) {
+            return Collections.emptySet();
+        } else if (size == 1) {
+            return Collections.singleton(elements[0]);
+        }
+
+        Set<E> set = new LinkedHashSet<>(size, FIXED_LOAD_FACTOR);
+        for (int i = 0; i < size; i++) {
+            set.add(elements[i]);
+        }
+        return Collections.unmodifiableSet(set);
+    }
+}
