Restore source compatibility

stream/src/main/java/com/annimon/stream/ComparatorCompat.java

@@ -50,6 +50,46 @@ public static <T extends Comparable<? super T>> ComparatorCompat<T> reverseOrder
         return (ComparatorCompat<T>) REVERSE_ORDER;
     }
 
+    /**
+     * Returns a comparator that reverses the order of the specified comparator.
+     * If the specified comparator is {@code null}, this method is equivalent
+     * to {@link #reverseOrder()}.
+     *
+     * @param <T> the type of the objects compared by the comparator
+     * @param comparator  a comparator to be reversed
+     * @return a comparator
+     * @see Collections#reverseOrder(java.util.Comparator)
+     * @throws NullPointerException if {@code comparator} is null
+     */
+    public static <T> Comparator<T> reversed(Comparator<T> comparator) {
+        return Collections.reverseOrder(comparator);
+    }
+
+    /**
+     * Returns a comparator that uses {@code c2} comparator
+     * if {@code c1} comparator considers two elements equal.
+     *
+     * @param <T> the type of the objects compared by the comparators
+     * @param c1  a first comparator
+     * @param c2  a second comparator
+     * @return a comparator
+     * @throws NullPointerException if {@code c1} or {@code c2} is null
+     */
+    public static <T> Comparator<T> thenComparing(
+            final Comparator<? super T> c1,
+            final Comparator<? super T> c2) {
+        Objects.requireNonNull(c1);
+        Objects.requireNonNull(c2);
+        return new Comparator<T>() {
+
+            @Override
+            public int compare(T t1, T t2) {
+                final int result = c1.compare(t1, t2);
+                return (result != 0) ? result : c2.compare(t1, t2);
+            }
+        };
+    }
+
     /**
      * Returns a comparator that uses a function that extracts a sort key
      * to be compared with the specified comparator.
@@ -235,6 +275,18 @@ public int compare(T t1, T t2) {
         });
     }
 
+    /**
+     * Allows to build comparators with method chaining.
+     *
+     * @param <T> the type of the objects compared by the comparator
+     * @param comparator  the comparator to be chained
+     * @return a {@code Chain} instance
+     */
+    public static <T> ComparatorCompat<T> chain(Comparator<T> comparator) {
+        return new ComparatorCompat<T>(comparator);
+    }
+
+
     private final Comparator<? super T> comparator;
 
     public ComparatorCompat(Comparator<? super T> comparator) {
@@ -331,6 +383,17 @@ public ComparatorCompat<T> thenComparingDouble(ToDoubleFunction<? super T> keyEx
         return thenComparing(comparingDouble(keyExtractor));
     }
 
+    /**
+     * Returns a chained {@code Comparator}.
+     *
+     * @deprecated  As of release 1.1.7, it is unnecessary to call this method.
+     * @return a comparator
+     */
+    @SuppressWarnings("unchecked")
+    public Comparator<T> comparator() {
+        return (Comparator<T>) comparator;
+    }
+
     @Override
     public int compare(T o1, T o2) {
         return comparator.compare(o1, o2);

stream/src/test/java/com/annimon/stream/ComparatorCompatTest.java

@@ -35,17 +35,19 @@ public void testReverseOrder() {
     public void testReversedComparator() {
         int[] expected = {1, -2, 4, -8, 16};
         IntStream stream = IntStream.of(-8, -2, 1, 4, 16)
-                .sorted(new ComparatorCompat<Integer>(Functions.descendingAbsoluteOrder())
-                        .reversed());
+                .sorted(ComparatorCompat.reversed(
+                        Functions.descendingAbsoluteOrder()
+                ));
         assertThat(stream.toArray(), is(expected));
     }
 
     @Test
     public void testThenComparing() {
         int[] expected = {16, -16, 4, -4, -2, 1};
         IntStream stream = IntStream.of(-16, -4, -2, 1, 4, 16)
-                .sorted(new ComparatorCompat<Integer>(Functions.descendingAbsoluteOrder())
-                        .thenComparing(ComparatorCompat.<Integer>reverseOrder()
+                .sorted(ComparatorCompat.thenComparing(
+                        Functions.descendingAbsoluteOrder(),
+                        ComparatorCompat.<Integer>reverseOrder()
                 ));
         assertThat(stream.toArray(), is(expected));
     }
@@ -251,6 +253,18 @@ public void testChain_NameReversedThenCourseThenSpeciality() {
         testStudentComparator(comparator);
     }
 
+    @Test
+    @SuppressWarnings("deprecation")
+    public void testChain_NameReversedThenCourseThenSpeciality_Deprecation() {
+        Comparator<Student> comparator = ComparatorCompat
+                .chain(ComparatorCompat.comparing(Students.studentName))
+                .reversed()
+                .thenComparing(Students.course)
+                .thenComparing(Students.speciality)
+                .comparator();
+        testStudentComparator(comparator);
+    }
+
     @Test
     public void testChain_NameReversedThenCourseThenSpecialityDoubleReversed() {
         Comparator<Student> comparator = ComparatorCompat