Merge pull request #4 from lokic/dev/0.2.0

feat: 支持left join的排序，不再兼容老的join方法

Author: lokic

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.github.lokic</groupId>
     <artifactId>java-plus</artifactId>
-    <version>0.1.4</version>
+    <version>0.2.0</version>
     <name>java-plus</name>
     <description>Provide some useful extensions on the basis of java8 to make java more usable.</description>
     <url>https://github.com/lokic/java-plus</url>

src/main/java/com/github/lokic/javaplus/join/Join.java

@@ -8,21 +8,4 @@ public static <T> JoinStream<T> stream(Stream<T> stream) {
         return new JoinStream<>(stream);
     }
 
-    public static <T1, T2> JoinType<T1, T2> innerJoin(Stream<T1> left, Stream<T2> right) {
-        return new JoinType<>(left, right, t -> t.getT1() != null && t.getT2() != null);
-    }
-
-    public static <T1, T2> JoinType<T1, T2> leftOuterJoin(Stream<T1> left, Stream<T2> right) {
-        return new JoinType<>(left, right, t -> t.getT1() != null);
-    }
-
-    public static <T1, T2> JoinType<T1, T2> rightOuterJoin(Stream<T1> left, Stream<T2> right) {
-        return new JoinType<>(left, right, t -> t.getT2() != null);
-    }
-
-    public static <T1, T2> JoinType<T1, T2> fullOuterJoin(Stream<T1> left, Stream<T2> right) {
-        return new JoinType<>(left, right, t -> !(t.getT1() == null && t.getT2() == null));
-    }
-
-
 }

src/main/java/com/github/lokic/javaplus/join/JoinStream.java

@@ -1,5 +1,7 @@
 package com.github.lokic.javaplus.join;
 
+import com.github.lokic.javaplus.tuple.Tuple;
+
 import java.util.function.Function;
 import java.util.stream.Stream;
 
@@ -18,22 +20,6 @@ public <R> Stream<R> flattenStream(Function<? super T, ? extends R> mapper) {
         return left.map(mapper);
     }
 
-    public <T3> JoinType<T, T3> innerJoin(Stream<T3> right) {
-        return Join.innerJoin(left, right);
-    }
-
-    public <T3> JoinType<T, T3> leftOuterJoin(Stream<T3> right) {
-        return Join.leftOuterJoin(left, right);
-    }
-
-    public <T3> JoinType<T, T3> rightOuterJoin(Stream<T3> right) {
-        return Join.rightOuterJoin(left, right);
-    }
-
-    public <T3> JoinType<T, T3> fullOuterJoin(Stream<T3> right) {
-        return Join.fullOuterJoin(left, right);
-    }
-
     public <U, K, R> JoinStream<R> innerJoin(Stream<U> right, JoinOn<T, U, K, R> on) {
         Stream<R> stream = innerJoin(right)
                 .on(on.getLeftKey(), on.getRightKey())
@@ -50,9 +36,10 @@ public <U, K, R> JoinStream<R> leftOuterJoin(Stream<U> right, JoinOn<T, U, K, R>
 
 
     public <U, K, R> JoinStream<R> rightOuterJoin(Stream<U> right, JoinOn<T, U, K, R> on) {
-        Stream<R> stream = rightOuterJoin(right)
-                .on(on.getLeftKey(), on.getRightKey())
-                .flattenStream(on.getFlatten());
+        Stream<R> stream = new JoinStream<>(right)
+                .leftOuterJoin(left)
+                .on(on.getRightKey(), on.getLeftKey())
+                .flattenStream(t -> on.getFlatten().apply(Tuple.of(t.getT2(), t.getT1())));
         return new JoinStream<>(stream);
     }
 
@@ -63,4 +50,17 @@ public <U, K, R> JoinStream<R> fullOuterJoin(Stream<U> right, JoinOn<T, U, K, R>
                 .flattenStream(on.getFlatten());
         return new JoinStream<>(stream);
     }
+
+    private <U> JoinType<T, U> innerJoin(Stream<U> right) {
+        return new JoinType<>(left, right, t -> t.getT1() != null && t.getT2() != null);
+    }
+
+    private <U> JoinType<T, U> leftOuterJoin(Stream<U> right) {
+        return new JoinType<>(left, right, t -> t.getT1() != null);
+    }
+
+    private <U> JoinType<T, U> fullOuterJoin(Stream<U> right) {
+        return new JoinType<>(left, right, t -> !(t.getT1() == null && t.getT2() == null));
+    }
+
 }

src/main/java/com/github/lokic/javaplus/join/JoinType.java

@@ -1,5 +1,6 @@
 package com.github.lokic.javaplus.join;
 
+import com.github.lokic.javaplus.Functions;
 import com.github.lokic.javaplus.NullData;
 import com.github.lokic.javaplus.tuple.Tuple;
 import com.github.lokic.javaplus.tuple.Tuple2;
@@ -13,23 +14,23 @@
 
 public class JoinType<T1, T2> {
 
-    private final Stream<Tuple2<T1, T2>> leftWrappedStream;
-    private final Stream<Tuple2<T1, T2>> rightWrappedStream;
+    private final Stream<Tuple2<Integer, Tuple2<T1, T2>>> leftWrappedStream;
+    private final Stream<Tuple2<Integer, Tuple2<T1, T2>>> rightWrappedStream;
     private final Predicate<Tuple2<T1, T2>> joinMatcher;
 
     JoinType(Stream<T1> left, Stream<T2> right, Predicate<Tuple2<T1, T2>> joinMatcher) {
-        this.leftWrappedStream = left.map(l -> Tuple.of(Objects.requireNonNull(l), null));
-        this.rightWrappedStream = right.map(r -> Tuple.of(null, Objects.requireNonNull(r)));
+        this.leftWrappedStream = left.map(l -> Tuple.of(Objects.requireNonNull(l), (T2) null)).map(Functions.mapWithIndex(Tuple::of));
+        this.rightWrappedStream = right.map(r -> Tuple.of((T1) null, Objects.requireNonNull(r))).map(Functions.mapWithIndex(Tuple::of));
         this.joinMatcher = joinMatcher;
     }
 
     public <K> JoinStream<Tuple2<T1, T2>> on(Function<T1, K> leftKey, Function<T2, K> rightKey) {
         Stream<Tuple2<T1, T2>> stream = Stream.concat(leftWrappedStream, rightWrappedStream)
                 .collect(Collectors.toMap(
-                        t -> matchKey(t, leftKey, rightKey),
+                        t -> matchKey(t.getT2(), leftKey, rightKey),
                         Collections::singletonList,
                         (a, b) -> {
-                            List<Tuple2<T1, T2>> li = new ArrayList<>();
+                            List<Tuple2<Integer, Tuple2<T1, T2>>> li = new ArrayList<>();
                             li.addAll(a);
                             li.addAll(b);
                             return li;
@@ -39,7 +40,9 @@ public <K> JoinStream<Tuple2<T1, T2>> on(Function<T1, K> leftKey, Function<T2, K
                 .values()
                 .stream()
                 .flatMap(this::cartesian)
-                .filter(this.joinMatcher);
+                .sorted(this::compare)
+                .filter(t -> joinMatcher.test(t.getT2()))
+                .map(Tuple2::getT2);
         return new JoinStream<>(stream);
     }
 
@@ -49,18 +52,21 @@ public <K> JoinStream<Tuple2<T1, T2>> on(Function<T1, K> leftKey, Function<T2, K
      * @param li
      * @return
      */
-    private Stream<Tuple2<T1, T2>> cartesian(List<Tuple2<T1, T2>> li) {
-        Map<Boolean, List<Tuple2<T1, T2>>> map = li.stream()
-                .collect(Collectors.partitioningBy(this::isLeft, this.toListOrNullList()));
-        List<Tuple2<T1, T2>> left = map.get(true);
-        List<Tuple2<T1, T2>> right = map.get(false);
+    private Stream<Tuple2<Tuple2<Integer, Integer>, Tuple2<T1, T2>>> cartesian(List<Tuple2<Integer, Tuple2<T1, T2>>> li) {
+        Map<Boolean, List<Tuple2<Integer, Tuple2<T1, T2>>>> map = li.stream()
+                .collect(Collectors.partitioningBy(t -> isLeft(t.getT2()), this.toListOrNullList()));
+        List<Tuple2<Integer, Tuple2<T1, T2>>> left = map.get(true);
+        List<Tuple2<Integer, Tuple2<T1, T2>>> right = map.get(false);
         return left.stream()
                 .flatMap(l -> right.stream()
                         .map(r -> this.merge(l, r)));
     }
 
-    private Tuple2<T1, T2> merge(Tuple2<T1, T2> l, Tuple2<T1, T2> r) {
-        return Tuple.of(l == null ? null : l.getT1(), r == null ? null : r.getT2());
+
+    private Tuple2<Tuple2<Integer, Integer>, Tuple2<T1, T2>> merge(Tuple2<Integer, Tuple2<T1, T2>> l, Tuple2<Integer, Tuple2<T1, T2>> r) {
+        return Tuple.of(
+                Tuple.of(l == null ? null : l.getT1(), r == null ? null : r.getT1()),
+                Tuple.of(l == null ? null : l.getT2().getT1(), r == null ? null : r.getT2().getT2()));
     }
 
     private boolean isLeft(Tuple2<T1, T2> t) {
@@ -93,4 +99,30 @@ private <T> Collector<T, List<T>, List<T>> toListOrNullList() {
                 }
         );
     }
+
+    private int compare(Tuple2<Tuple2<Integer, Integer>, Tuple2<T1, T2>> a, Tuple2<Tuple2<Integer, Integer>, Tuple2<T1, T2>> b) {
+        Tuple2<Integer, Integer> ta = a.getT1();
+        Tuple2<Integer, Integer> tb = b.getT1();
+
+        int cmp = compare(ta.getT1(), tb.getT1());
+        if (cmp == 0) {
+            return compare(ta.getT2(), tb.getT2());
+        }
+        return cmp;
+    }
+
+
+    private int compare(Integer a, Integer b) {
+        if (a == null && b == null) {
+            return 0;
+        }
+        if (a == null) {
+            return 1;
+        }
+        if (b == null) {
+            return -1;
+        }
+        return Integer.compare(a, b);
+    }
+
 }