Merge branch 'main' into completed

Author: tboychuk

5-0-functional-programming/5-1-1-crazy-lambdas/src/main/java/com/bobocode/fp/CrazyLambdas.java

@@ -3,6 +3,7 @@
 import com.bobocode.util.ExerciseNotCompletedException;
 
 import java.math.BigDecimal;
+import java.util.Comparator;
 import java.util.Map;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.function.*;
@@ -249,6 +250,44 @@ public static BiFunction<Map<String, IntUnaryOperator>, String, IntUnaryOperator
         return (functionMap, functionName) -> functionMap.getOrDefault(functionName, IntUnaryOperator.identity());
     }
 
+    /**
+     * Returns a comparator of type T that is comparing values extracted using the provided mapper function.
+     * <p>
+     * E.g. imagine you need to compare accounts by their balance values.
+     * <pre>{@code
+     * Comparator<Account> balanceComparator = comparing(Account::getBalance);
+     * }</pre>
+     * <p>
+     * PLEASE NOTE, that @{@link Comparator} is a functional interface, and you should manually write a lambda expression
+     * to implement it.
+     *
+     * @param mapper a mapper function that allows to map an object to a comparable value
+     * @return a comparator instance
+     */
+    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> mapper) {
+        throw new ExerciseNotCompletedException();
+    }
+
+    /**
+     * Returns a comparator of type T that uses a provided comparator to compare objects, and only if they are equal
+     * it's comparing values extracted using the provided mapper function.
+     * <p>
+     * E.g. suppose you want to compare accounts by balance, but in case two people have the same balance you want to
+     * compare their first names:
+     * <pre>{@code
+     * Comparator<Account> accountComparator = thenComparing(balanceComparator, Account::getFirstName);
+     * }</pre>
+     * <p>
+     *
+     * @param comparator an initial comparator
+     * @param mapper     a mapper function that is used to extract values when initial comparator returns zero
+     * @return a comparator instance
+     */
+    public static <T, U extends Comparable<? super U>> Comparator<T> thenComparing(
+            Comparator<? super T> comparator, Function<? super T, ? extends U> mapper) {
+        throw new ExerciseNotCompletedException();
+    }
+
     /**
      * Returns {@link Supplier} of {@link Supplier} of {@link Supplier} of {@link String} "WELL DONE!".
      *

5-0-functional-programming/5-1-1-crazy-lambdas/src/test/java/com/bobocode/fp/CrazyLambdasTest.java

@@ -6,12 +6,11 @@
 import org.junit.jupiter.api.TestMethodOrder;
 
 import java.math.BigDecimal;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Queue;
+import java.util.*;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.function.*;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.*;
 
 /**
@@ -252,6 +251,29 @@ void functionLoader() {
 
     @Test
     @Order(18)
+    void comparing() {
+        var strLengthComparator = CrazyLambdas.comparing(String::length);
+        var stringList = new ArrayList<>(List.of("Me", "I", "All of us", "They", "She"));
+
+        stringList.sort(strLengthComparator);
+
+        assertThat(stringList).isEqualTo(List.of("I", "Me", "She", "They", "All of us"));
+    }
+
+    @Test
+    @Order(19)
+    void thenComparing() {
+        var strLengthComparator = Comparator.comparing(String::length);
+        var lengthThenNaturalComparator = CrazyLambdas.thenComparing(strLengthComparator, s -> s);
+        var stringList = new ArrayList<>(List.of("Me", "I", "All of us", "They", "She", "He"));
+
+        stringList.sort(lengthThenNaturalComparator);
+
+        assertThat(stringList).isEqualTo(List.of("I", "He", "Me", "She", "They", "All of us"));
+    }
+
+    @Test
+    @Order(20)
     void trickyWellDoneSupplier() {
         Supplier<Supplier<Supplier<String>>> wellDoneSupplier = CrazyLambdas.trickyWellDoneSupplier();