Lambda tutorial

- implemented MethodReference.java, MethodReferenceExamples.java
- refactored lambda examples
- removed FunctionFactoryTask.java

Author: Taras

function-factory-task/pom.xml

@@ -4,7 +4,6 @@
 import com.bobocode.functions.Condition;
 import com.bobocode.functions.Operation;
 import com.bobocode.model.Account;
-import com.bobocode.util.TestDataProvider;
 
 import java.math.BigDecimal;
 import java.time.LocalDate;

function-factory-task/src/main/java/com/bobocode/FunctionFactoryTask.java

@@ -4,15 +4,12 @@
 import com.bobocode.functions.Condition;
 import com.bobocode.functions.Operation;
 import com.bobocode.model.Account;
-import com.bobocode.util.TestDataProvider;
 
 import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.Period;
 import java.util.List;
 
-import static java.time.Period.between;
-
 /**
  * Behavior parameterization with Lambdas.
  *

lambdas/src/main/java/com/bobocode/BehaviorParameterizationWithAnonymousClasses.java

@@ -2,7 +2,6 @@
 
 import com.bobocode.data.Accounts;
 import com.bobocode.model.Account;
-import com.bobocode.util.TestDataProvider;
 
 import java.math.BigDecimal;
 import java.time.LocalDate;

lambdas/src/main/java/com/bobocode/BehaviorParameterizationWithLambda.java

@@ -1,40 +1,36 @@
 package com.bobocode;
 
+import com.bobocode.data.Accounts;
+import com.bobocode.model.Account;
+
+import java.util.List;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
 /**
- * Created by taras on 8/11/17.
+ * Method reference is a shorthand for lambda expression that could be use in some cases for better readability.
  */
 public class MethodReference {
     public static void main(String[] args) {
-        // 1 - method reference to static method
-        Function<Integer, Integer> absFunction = Math::abs;
-
-        int a = 5;
-
-        Function<Integer, Integer> f;
-
-        // 2 - methods reference to instance method
-        String hello = "Hello";
-        Supplier<String> helloUppercaseSupplier = hello::toUpperCase;
-        doSomethingWithStringSupplier(helloUppercaseSupplier);
+        List<Account> accounts = Accounts.getAccountList(10);
 
-        // 3 - special case (ClassName::objMethodName)
-        Function<String, String> toUpperCase = String::toUpperCase;
-        toUpperCase.apply("hello");
+        printAccountsWithLambda(accounts);
+        printAccountsWithMethodReference(accounts);
     }
 
-    static void doSomethingWithStringSupplier(Supplier<String> stringSupplier) {
-
+    private static void printAccountsWithLambda(List<Account> accounts) {
+        consumeAccounts(accounts, a -> System.out.println(a));
     }
 
-    static String computeSomething() {
-        // some operation
-        return "hello";
+    private static void printAccountsWithMethodReference(List<Account> accounts) {
+        consumeAccounts(accounts, System.out::println); //todo: think what if you want to print only emails
     }
 
-    static void processSomething(String s) {
-
+    private static void consumeAccounts(List<Account> accounts, Consumer<Account> consumer) {
+        for (Account account : accounts){
+            consumer.accept(account);
+        }
     }
+
 }

lambdas/src/main/java/com/bobocode/HardcodedBehavior.java

@@ -0,0 +1,30 @@
+package com.bobocode;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/**
+ * A list of method reference examples.
+ */
+public class MethodReferenceExamples {
+    public static void main(String[] args) {
+        printAbsUsingMethodReference(-23);
+        printSumUsingMethodReference(25, 50);
+    }
+
+    private static void printAbsUsingMethodReference(int a) {
+        Function<Integer, Integer> absFunction = Math::abs;
+        int result = absFunction.apply(a);
+
+        System.out.println("abd(" + a + ") = " + result);
+    }
+
+    private static void printSumUsingMethodReference(int a, int b) {
+        BiFunction<Integer, Integer, Integer> sumFunction = Math::addExact;
+        int result = sumFunction.apply(a, b);
+
+        System.out.println(a +" + "+ b + " = " + result);
+    }
+
+
+}

lambdas/src/main/java/com/bobocode/MethodReference.java

@@ -0,0 +1,41 @@
+package com.bobocode;
+
+import com.bobocode.data.Accounts;
+import com.bobocode.model.Account;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.Period;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * Predefined interface is a standard @{@link FunctionalInterface} that represent some well-known function type.
+ * E.g. @{@link java.util.function.Predicate}, @{@link java.util.function.Function}, @{@link java.util.function.Consumer}
+ *
+ * The same example with custom functional interfaces was shown in {@link BehaviorParameterizationWithLambda}
+ */
+public class PredefinedInterface {
+    public static void main(String[] args) {
+        List<Account> accounts = Accounts.getAccountList(10);
+
+        processAccounts(accounts,
+                a -> Period.between(a.getCreationDate().toLocalDate(), LocalDate.now()).getYears() > 4,
+                a -> a.setBalance(a.getBalance().add(BigDecimal.valueOf(50))));
+    }
+
+    /**
+     * Customer functional interfaces @{@link com.bobocode.functions.Operation}, and @{@link com.bobocode.functions.Condition}
+     * were removed in favor of standard ones @{@link Consumer}, and @{@link Predicate} accordingly
+     */
+    private static void processAccounts(List<Account> accounts, Predicate<Account> accountPredicate,
+                                        Consumer<Account> accountConsumer) {
+        for (Account account : accounts) {
+            if (accountPredicate.test(account)) {
+                accountConsumer.accept(account);
+            }
+        }
+    }
+
+}

lambdas/src/main/java/com/bobocode/MethodReferenceExamples.java

@@ -0,0 +1,74 @@
+package com.bobocode;
+
+import com.bobocode.data.Accounts;
+import com.bobocode.model.Account;
+
+import java.util.Random;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.IntStream;
+
+/**
+ * A list of predefined interfaces examples.
+ */
+public class PredefinedInterfacesExamples {
+    public static void main(String[] args) {
+
+        printEmailUsingAccountConsumer();
+
+        printARandomNumberUsingIntegerSupplier();
+
+        calculate3xValueUsingIntegerFunction();
+
+        checkIfNumberIsPositiveUsingIntegerPredicate();
+
+        verifyGoogleEmailUsingAccountPredicate();
+
+        printPrimeNumbersUsingIntegerPredicate();
+
+    }
+
+    private static void printARandomNumberUsingIntegerSupplier() {
+        Supplier<Integer> integerSupplier = () -> new Random().nextInt(1000);
+
+        System.out.println("Next value: " + integerSupplier.get());
+    }
+
+    private static void printEmailUsingAccountConsumer() {
+        Consumer<Account> accountConsumer = acc -> System.out.println(acc.getEmail());
+        Account account = Accounts.getAccount();
+
+        accountConsumer.accept(account);
+    }
+
+    private static void calculate3xValueUsingIntegerFunction() {
+        Function<Integer, Integer> tripleFunction = n -> 3 * n;
+        int a = 12;
+
+        System.out.println("3 * " + a + tripleFunction.apply(a));
+    }
+
+    private static void checkIfNumberIsPositiveUsingIntegerPredicate() {
+        Predicate<Integer> isPositive = n -> n > 0;
+        int b = 23;
+
+        System.out.println(b + " is " + (isPositive.test(b) ? "positive" : "negative"));
+    }
+
+    private static void verifyGoogleEmailUsingAccountPredicate() {
+        Account account = Accounts.getAccount();
+        Predicate<Account> isGmailUser = a -> a.getEmail().endsWith("@gmail.com");
+
+        System.out.println("\"" + account.getEmail() + "\"" + " is "
+                + (isGmailUser.test(account) ? "" : "not") + " a Google mail.");
+    }
+
+    private static void printPrimeNumbersUsingIntegerPredicate() {
+        Predicate<Integer> isPrime = n -> IntStream.range(2, n).noneMatch(i -> n % i == 0);
+
+        IntStream.range(1, 10)
+                .forEach(i -> System.out.printf("%3d %10s\n", i, (isPrime.test(i) ? " is prime" : "")));
+    }
+}

lambdas/src/main/java/com/bobocode/PredefinedInterface.java

@@ -3,7 +3,6 @@
 
 import com.bobocode.data.Accounts;
 import com.bobocode.model.Account;
-import com.bobocode.util.TestDataProvider;
 
 import java.util.List;
 import java.util.Optional;

lambdas/src/main/java/com/bobocode/PredefinedInterfaces.java

@@ -4,16 +4,11 @@
 import com.bobocode.data.Accounts;
 import com.bobocode.model.Account;
 import com.bobocode.model.CreditAccount;
-import com.bobocode.util.TestDataProvider;
 
 import java.math.BigDecimal;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
-import java.util.OptionalDouble;
-
-import static java.util.Comparator.comparing;
-import static java.util.stream.Collectors.maxBy;
 
 /**
  *