- renamed examples according the convention

- added couple examples like ImperativeVsDeclarativeFiltering.java, and
MethodRefToUpperCaseExample.java

Author: Taras

lambdas/src/main/java/com/bobocode/MethodReference.java renamed to lambdas/src/main/java/com/bobocode/LambdaAndMethodReference.java

@@ -9,7 +9,7 @@
 /**
  * Method reference is a shorthand for lambda expression that could be use in some cases for better readability.
  */
-public class MethodReference {
+public class LambdaAndMethodReference {
     public static void main(String[] args) {
         List<Account> accounts = Accounts.getAccountList(10);
 

lambdas/src/main/java/com/bobocode/ComparatorExample.java renamed to lambdas/src/main/java/com/bobocode/LambdaComparatorExample.java

@@ -8,7 +8,7 @@
 
 import static java.util.Comparator.comparing;
 
-public class ComparatorExample {
+public class LambdaComparatorExample {
 
     public static void main(String[] args) {
         List<Account> accounts = Accounts.getAccountList(10);

lambdas/src/main/java/com/bobocode/RunnableExample.java renamed to lambdas/src/main/java/com/bobocode/LambdaRunnableExample.java

@@ -1,6 +1,6 @@
 package com.bobocode;
 
-public class RunnableExample {
+public class LambdaRunnableExample {
     public static void main(String[] args) {
         sayHelloFromNewThread();
         sayHelloFromNewThreadUsingLambda();

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

@@ -0,0 +1,50 @@
+package com.bobocode;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/**
+ * A list of different examples of method reference usage.
+ */
+public class MethodRefToUpperCaseExample {
+    public static void main(String[] args) {
+        String s = "Method reference insights";
+
+        printUpperStringUsingFunction(s);
+        printUpperStringUsingUnaryOperation(s);
+        printUpperStringUsingStringSupplier(s);
+    }
+
+    /**
+     * This is the unbound method reference example. Since we used unbound method reference, the {@link Function} can
+     * receive a string as an input parameter.
+     */
+    private static void printUpperStringUsingFunction(String s) {
+        Function<String, String> upperCaseFunction = String::toUpperCase;
+
+        System.out.println(upperCaseFunction.apply(s));
+    }
+
+    /**
+     * This is the unbound method reference example. Since toUpperCase() receives and returns the same type
+     * {@link String}, we can easily replace {@link Function} with {@link UnaryOperator}
+     */
+    private static void printUpperStringUsingUnaryOperation(String s) {
+        UnaryOperator<String> upperCaseOperator = String::toUpperCase;
+
+        System.out.println(upperCaseOperator.apply(s));
+    }
+
+    /**
+     * This is the bound method reference example. We actually reference a method that is bound to concrete
+     * string instance. Since we reference a concrete string, there is no input parameter, only an output. In this case
+     * we can use {@link Supplier}
+     */
+    private static void printUpperStringUsingStringSupplier(String s) {
+        Supplier<String> stringSupplier = s::toUpperCase;
+
+        System.out.println(stringSupplier.get());
+    }
+
+}

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

@@ -1,7 +1,6 @@
 package com.bobocode;
 
-import java.util.function.BiFunction;
-import java.util.function.Function;
+import java.util.function.*;
 
 /**
  * A list of method reference examples.
@@ -10,21 +9,27 @@ public class MethodReferenceExamples {
     public static void main(String[] args) {
         printAbsUsingMethodReference(-23);
         printSumUsingMethodReference(25, 50);
+        printUpperStringUsingMethodReference("Lambda is awesome!");
     }
 
     private static void printAbsUsingMethodReference(int a) {
-        Function<Integer, Integer> absFunction = Math::abs;
-        int result = absFunction.apply(a);
+        IntUnaryOperator absOperator = Math::abs;
+        int result = absOperator.applyAsInt(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);
+        IntBinaryOperator sumOperator = Math::addExact;
+        int result = sumOperator.applyAsInt(a, b);
 
-        System.out.println(a +" + "+ b + " = " + result);
+        System.out.println("\n" + a + " + " + b + " = " + result);
     }
 
+    private static void printUpperStringUsingMethodReference(String s) {
+        UnaryOperator<String> upperOperation = String::toUpperCase;
+
+        System.out.println("\n" + s + " -> " + upperOperation.apply(s));
+    }
 
 }

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

@@ -0,0 +1,36 @@
+package com.bobocode;
+
+import java.util.Random;
+import java.util.function.DoubleSupplier;
+import java.util.function.IntToDoubleFunction;
+import java.util.function.LongBinaryOperator;
+
+/**
+ * Always use special classes for Primitives
+ */
+public class PredefinedInterfacePrimitives {
+    public static void main(String[] args) {
+        printRandomDoubleUsingSupplier();
+        printLongSumUsingBinaryOperation(124124L, 132134L);
+        printSqrtUsingFunction(25);
+    }
+
+    private static void printRandomDoubleUsingSupplier() {
+        DoubleSupplier doubleSupplier = () -> new Random().nextDouble();
+
+        System.out.println("Random double: " + doubleSupplier.getAsDouble());
+    }
+
+    private static void printLongSumUsingBinaryOperation(long a, long b) {
+        LongBinaryOperator sumOperator = Long::sum;
+
+        System.out.println("\n" + a + " " + b + " = " + sumOperator.applyAsLong(a, b));
+    }
+
+    private static void printSqrtUsingFunction(int a) {
+        IntToDoubleFunction sqrtFunction = Math::sqrt;
+
+        System.out.println("\nsqrt(" + a + ") = " + sqrtFunction.applyAsDouble(a));
+    }
+
+}

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

@@ -4,71 +4,61 @@
 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.function.*;
 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);
+        IntSupplier integerSupplier = () -> new Random().nextInt(1000);
 
-        System.out.println("Next value: " + integerSupplier.get());
+        System.out.println("\nNext random value: " + integerSupplier.getAsInt());
     }
 
     private static void printEmailUsingAccountConsumer() {
-        Consumer<Account> accountConsumer = acc -> System.out.println(acc.getEmail());
+        Consumer<Account> accountConsumer = acc -> System.out.println("\nAccount email: " + acc.getEmail());
         Account account = Accounts.getAccount();
 
         accountConsumer.accept(account);
     }
 
     private static void calculate3xValueUsingIntegerFunction() {
-        Function<Integer, Integer> tripleFunction = n -> 3 * n;
+        IntUnaryOperator tripleFunction = n -> 3 * n;
         int a = 12;
 
-        System.out.println("3 * " + a + tripleFunction.apply(a));
+        System.out.println("\n3 * " + a + " = " + tripleFunction.applyAsInt(a));
     }
 
     private static void checkIfNumberIsPositiveUsingIntegerPredicate() {
-        Predicate<Integer> isPositive = n -> n > 0;
-        int b = 23;
+        IntPredicate isPositive = n -> n > 0;
+        int b = new Random().nextInt();
 
-        System.out.println(b + " is " + (isPositive.test(b) ? "positive" : "negative"));
+        System.out.println("\n" + 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.");
+        System.out.println("\n" + account.getEmail() + " is "
+                + (isGmailUser.test(account) ? "" : "not") + " a Google email.");
     }
 
     private static void printPrimeNumbersUsingIntegerPredicate() {
-        Predicate<Integer> isPrime = n -> IntStream.range(2, n).noneMatch(i -> n % i == 0);
-
-        IntStream.range(1, 10)
+        IntPredicate isPrime = n -> IntStream.range(2, n).noneMatch(i -> n % i == 0);
+        System.out.println();
+        IntStream.rangeClosed(1, 25)
                 .forEach(i -> System.out.printf("%3d %10s\n", i, (isPrime.test(i) ? " is prime" : "")));
     }
 }

optional/src/main/java/com/bobocode/OptionalMappingExample.java renamed to optional/src/main/java/com/bobocode/OptionalMapping.java

@@ -10,7 +10,7 @@
 import java.util.List;
 import java.util.Optional;
 
-public class OptionalMappingExample {
+public class OptionalMapping {
     public static void main(String[] args) {
         List<Account> accounts = Accounts.getAccountList(10);
         List<CreditAccount> creditAccounts = Collections.singletonList(new CreditAccount(BigDecimal.valueOf(1000)));

optional/src/main/java/com/bobocode/OptionalForPrimitivesExample.java renamed to optional/src/main/java/com/bobocode/OptionalPrimitives.java

@@ -7,7 +7,7 @@
 import java.util.List;
 import java.util.OptionalDouble;
 
-public class OptionalForPrimitivesExample {
+public class OptionalPrimitives {
     public static void main(String[] args) {
         List<Account> accounts = Accounts.getAccountList(10);
 

optional/src/main/java/com/bobocode/OptionalReturningMethodExample.java renamed to optional/src/main/java/com/bobocode/OptionalReturningMethod.java

@@ -7,7 +7,7 @@
 import java.util.Optional;
 import java.util.Random;
 
-public class OptionalReturningMethodExample {
+public class OptionalReturningMethod {
     public static void main(String[] args) {
         List<Account> accounts = Accounts.getAccountList(20);
         Optional<Account> luckyGuy = findLuckyGuy(accounts);