Merge branch 'master' into exercise/completed

# Conflicts:
#	crazy-lambdas/src/main/java/com/bobocode/CrazyLambdas.java

Author: tboychuk

account-analytics/src/main/java/com.bobocode/AccountAnalytics.java

@@ -163,7 +163,7 @@ public Map<String, BigDecimal> collectBalancesByIdForAccountsCreatedOn(int year)
      * Returns a {@link Map} where key is {@link Account#lastName} and values is a {@link Set} that contains first names
      * of all accounts with a specific last name.
      *
-     * @return a map where key is a first name and value is a set of first names
+     * @return a map where key is a last name and value is a set of first names
      */
     public Map<String, Set<String>> groupFirstNamesByLastNames() {
         return accounts.stream()

crazy-lambdas/src/main/java/com/bobocode/CrazyLambdas.java

@@ -2,6 +2,7 @@
 
 import java.math.BigDecimal;
 import java.util.concurrent.ThreadLocalRandom;
+import java.util.Map;
 import java.util.function.*;
 
 public class CrazyLambdas {
@@ -24,6 +25,16 @@ public static Predicate<String> isEmptyPredicate() {
         return String::isEmpty;
     }
 
+    /**
+     * Return a {@link Function} that accepts {@link String} and returns that string repeated n time, where n is passed
+     * as function argument
+     *
+     * @return function that repeats Strings
+     */
+    public static BiFunction<String, Integer, String> stringMultiplier() {
+        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+    }
+
     /**
      * Returns a {@link Function} that converts a {@link BigDecimal} number into a {@link String} that start with
      * a dollar sign and then gets a value
@@ -103,6 +114,15 @@ public static Supplier<IntUnaryOperator> nMultiplyFunctionSupplier(int n) {
         return () -> a -> n * a;
     }
 
+    /**
+     * Returns a {@link UnaryOperator} that accepts str to str function and returns the same function composed with trim
+     *
+     * @return function that composes functions with trim() function
+     */
+    public static UnaryOperator<Function<String, String>> composeWithTrimFunction() {
+        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+    }
+
     /**
      * Receives a {@link Runnable} parameter, and returns a {@link Supplier<Thread>}. The thread will be started only
      * when you call supplier method {@link Supplier#get()}
@@ -154,6 +174,17 @@ public static BiFunction<IntUnaryOperator, IntPredicate, IntUnaryOperator> funct
         return (intOperation, intPredicate) -> a -> intPredicate.test(a) ? intOperation.applyAsInt(a) : a;
     }
 
+    /**
+     * Returns a {@link BiFunction} which first parameter is a {@link Map} where key is a function name, and value is some
+     * {@link IntUnaryOperator}, and second parameter is a {@link String} which is a function name. If the map contains a
+     * function by a given name then it is returned by high order function otherwise an identity() is returned.
+     *
+     * @return a high-order function that fetches a function from a function map by a given name or returns identity()
+     */
+    public static BiFunction<Map<String, IntUnaryOperator>, String, IntUnaryOperator> functionLoader() {
+        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+    }
+
     /**
      * Returns {@link Supplier} of {@link Supplier} of {@link Supplier} of {@link String} "WELL DONE".
      *

crazy-lambdas/src/test/java/com/bobocode/CrazyLambdasTest.java

@@ -6,7 +6,9 @@
 
 import java.math.BigDecimal;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.function.*;
@@ -35,6 +37,17 @@ public void testIsEmptyPredicate() {
         assertTrue(emptyStringResult);
     }
 
+    @Test
+    public void testStringMultiplier() {
+        BiFunction<String, Integer, String> stringMultiplier = CrazyLambdas.stringMultiplier();
+
+        String threeTimesHi = stringMultiplier.apply("Hi", 3);
+        String twoTimesHello = stringMultiplier.apply("Hello", 2);
+
+        assertEquals("HiHiHi", threeTimesHi);
+        assertEquals("HelloHello", twoTimesHello);
+    }
+
     @Test
     public void testToDollarStringFunction() {
         Function<BigDecimal, String> toDollarStringFunction = CrazyLambdas.toDollarStringFunction();
@@ -131,6 +144,19 @@ public void testNMultiplyFunctionSupplier() {
         assertEquals(55, result);
     }
 
+    @Test
+    public void testComposeWithTrimFunction() {
+        UnaryOperator<Function<String, String>> composeWithTrimFunction = CrazyLambdas.composeWithTrimFunction();
+        Function<String, String> toLowerWithTrim = composeWithTrimFunction.apply(String::toLowerCase);
+        Function<String, String> threeTimesRepeatWithTrim = composeWithTrimFunction.apply(s -> s.repeat(3));
+
+        String hey = toLowerWithTrim.apply("  Hey ");
+        String threeTimesHi = threeTimesRepeatWithTrim.apply("  Hi  ");
+
+        assertEquals("hey", hey);
+        assertEquals("HiHiHi", threeTimesHi);
+    }
+
     @Test
     public void testRunningThreadSupplier() throws InterruptedException {
         Queue<Integer> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
@@ -187,6 +213,23 @@ public void testFunctionToConditionalFunction() {
         assertEquals(5, abs.applyAsInt(5));
     }
 
+    @Test
+    public void testFunctionLoader() {
+        BiFunction<Map<String, IntUnaryOperator>, String, IntUnaryOperator> functionLoader = CrazyLambdas.functionLoader();
+        Map<String, IntUnaryOperator> functionMap = new HashMap<>();
+        functionMap.put("increment", x -> x + 1);
+        functionMap.put("square", x -> x * x);
+
+        IntUnaryOperator incrementFunction = functionLoader.apply(functionMap, "increment");
+        IntUnaryOperator squareFunction = functionLoader.apply(functionMap, "square");
+        IntUnaryOperator identityFunction = functionLoader.apply(functionMap, "none");
+
+        assertEquals(5, incrementFunction.applyAsInt(4));
+        assertEquals(9, squareFunction.applyAsInt(3));
+        assertEquals(10, identityFunction.applyAsInt(10));
+    }
+
+
     @Test
     public void testTrickyWellDoneSupplier() {
         Supplier<Supplier<Supplier<String>>> wellDoneSupplier = CrazyLambdas.trickyWellDoneSupplier();

pom.xml

@@ -17,8 +17,8 @@
     </modules>
 
     <properties>
-        <maven.compiler.source>1.10</maven.compiler.source>
-        <maven.compiler.target>1.10</maven.compiler.target>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
     </properties>
 
     <dependencies>