From 741fc2e6bdab6e059684bfd07786016b41009294 Mon Sep 17 00:00:00 2001
From: lihongjie0209 <lihongjie0209@gmail.com>
Date: Sun, 10 Sep 2023 20:24:41 +0800
Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=B7=A5=E5=85=B7=E7=B1=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../coal/common/CollectionUtils.java          | 80 +++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 src/main/java/cn/lihongjie/coal/common/CollectionUtils.java

diff --git a/src/main/java/cn/lihongjie/coal/common/CollectionUtils.java b/src/main/java/cn/lihongjie/coal/common/CollectionUtils.java
new file mode 100644
index 00000000..e1b1b339
--- /dev/null
+++ b/src/main/java/cn/lihongjie/coal/common/CollectionUtils.java
@@ -0,0 +1,80 @@
+package cn.lihongjie.coal.common;
+
+import io.vavr.Tuple2;
+import lombok.experimental.UtilityClass;
+import org.apache.commons.lang3.ObjectUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+@UtilityClass
+public class CollectionUtils {
+
+    public static <Data, T> List<T> map(Iterable<Data> data, Function<Data, T> fn) {
+
+        return StreamSupport.stream(data.spliterator(), false).map(fn).collect(java.util.stream.Collectors.toList());
+    }
+
+    public static <A, B, K> List<Tuple2<A, B>> innerHashJoin(Iterable<A> a, Iterable<B> b, Function<A, K> ak, Function<B, K> bk) {
+        Map<K, List<A>> aMap = newStream(a).collect(Collectors.groupingBy(ak));
+        Map<K, List<B>> bMap = newStream(b).collect(Collectors.groupingBy(bk));
+        return aMap.keySet().stream().flatMap(k -> aMap.getOrDefault(k, new ArrayList<>()).stream().flatMap(av -> bMap.getOrDefault(k, new ArrayList<>()).stream().map(bv -> new Tuple2<>(av, bv)))).collect(java.util.stream.Collectors.toList());
+    }
+
+    public static <A, B> List<Tuple2<A, B>> innerNestJoin(Iterable<A> a, Iterable<B> b, BiFunction<A, B, Boolean> test) {
+        a = ObjectUtils.defaultIfNull(a, new ArrayList<>());
+        b = ObjectUtils.defaultIfNull(b, new ArrayList<>());
+
+        List<Tuple2<A, B>> ans = new ArrayList<>();
+
+        for (A a1 : a) {
+            for (B b1 : b) {
+                if (test.apply(a1, b1)) {
+                    ans.add(new Tuple2<>(a1, b1));
+                }
+            }
+
+        }
+        return ans;
+    }
+
+    public static <A, B, K> List<Tuple2<A, B>> leftHashJoin(Iterable<A> a, Iterable<B> b, Function<A, K> ak, Function<B, K> bk) {
+        Map<K, List<A>> aMap = newStream(a).collect(Collectors.groupingBy(ak));
+        Map<K, List<B>> bMap = newStream(b).collect(Collectors.groupingBy(bk));
+        return aMap.keySet().stream().flatMap(k -> aMap.getOrDefault(k, new ArrayList<>()).stream().flatMap(av -> bMap.getOrDefault(k, List.of((B) null)).stream().map(bv -> new Tuple2<>(av, bv)))).collect(java.util.stream.Collectors.toList());
+    }
+
+    public static <A, B> List<Tuple2<A, B>> leftNestJoin(Iterable<A> a, Iterable<B> b, BiFunction<A, B, Boolean> test) {
+        a = ObjectUtils.defaultIfNull(a, new ArrayList<>());
+        b = ObjectUtils.defaultIfNull(b, new ArrayList<>());
+
+        List<Tuple2<A, B>> ans = new ArrayList<>();
+
+        for (A a1 : a) {
+            boolean find = false;
+            for (B b1 : b) {
+                if (test.apply(a1, b1)) {
+                    ans.add(new Tuple2<>(a1, b1));
+                    find = true;
+                }
+            }
+            if (!find) {
+                ans.add(new Tuple2<>(a1, null));
+            }
+        }
+        return ans;
+    }
+
+
+    private static <A> Stream<A> newStream(Iterable<A> a) {
+        return StreamSupport.stream(a == null ? new ArrayList<A>().spliterator() : a.spliterator(), false);
+    }
+
+
+}