- upgraded Java up to 10

- removed old examples like BehaviorParameterizationWithLambda.java
- added new lambda, and optional examples like ComparatorExample.java
- refactored Stream API tutorial

Author: Taras

account-data/src/main/java/com/bobocode/data/Accounts.java

@@ -1,43 +1,62 @@
 package com.bobocode.data;
 
 import com.bobocode.model.Account;
+import com.bobocode.model.CreditAccount;
 import io.codearte.jfairy.Fairy;
 import io.codearte.jfairy.producer.person.Person;
 
-import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Random;
-import java.util.stream.IntStream;
 
+import static java.math.BigDecimal.valueOf;
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.IntStream.range;
 
 public interface Accounts {
-    static Account getAccount(){
-        Fairy fairy = Fairy.create();
-        Person person = fairy.person();
-        Random random = new Random();
-
-
+    static Account getAccount() {
         Account fakeAccount = new Account();
-        fakeAccount.setFirstName(person.getFirstName());
-        fakeAccount.setLastName(person.getLastName());
-        fakeAccount.setEmail(person.getEmail());
-        fakeAccount.setBirthday(LocalDate.of(
-                person.getDateOfBirth().getYear(),
-                person.getDateOfBirth().getMonthOfYear(),
-                person.getDateOfBirth().getDayOfMonth()));
-        fakeAccount.setBalance(BigDecimal.valueOf(random.nextInt(200_000)));
-        fakeAccount.setCreationDate(LocalDateTime.now());
+        initializeFakeFields(fakeAccount);
 
         return fakeAccount;
     }
 
-    static List<Account> getAccountList(int size){
+    static List<Account> getAccountList(int size) {
         return range(0, size)
                 .mapToObj(i -> getAccount())
                 .collect(toList());
     }
+
+    static CreditAccount getCreditAccount() {
+        Random random = new Random();
+        CreditAccount creditAccount = new CreditAccount();
+        initializeFakeFields(creditAccount);
+        creditAccount.setCreditBalance(valueOf(random.nextInt(100_000)));
+
+        return creditAccount;
+    }
+
+    static List<CreditAccount> getCreditAccountsList(int size) {
+        return range(0, size)
+                .mapToObj(i -> getCreditAccount())
+                .collect(toList());
+    }
+
+
+    private static void initializeFakeFields(Account account) {
+        Fairy fairy = Fairy.create();
+        Person person = fairy.person();
+        Random random = new Random();
+
+        account.setFirstName(person.getFirstName());
+        account.setLastName(person.getLastName());
+        account.setEmail(person.getEmail());
+        account.setBirthday(LocalDate.of(
+                person.getDateOfBirth().getYear(),
+                person.getDateOfBirth().getMonthOfYear(),
+                person.getDateOfBirth().getDayOfMonth()));
+        account.setBalance(valueOf(random.nextInt(200_000)));
+        account.setCreationDate(LocalDateTime.now());
+    }
 }

optional/src/main/java/com/bobocode/model/CreditAccount.java renamed to account-data/src/main/java/com/bobocode/model/CreditAccount.java

@@ -2,11 +2,13 @@
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 
 import java.math.BigDecimal;
 import java.util.Optional;
 
+@NoArgsConstructor
 @AllArgsConstructor(access = AccessLevel.PUBLIC)
 @Setter
 public class CreditAccount extends Account {

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

@@ -0,0 +1,36 @@
+package com.bobocode;
+
+import com.bobocode.data.Accounts;
+import com.bobocode.model.Account;
+
+import java.util.Comparator;
+import java.util.List;
+
+import static java.util.Comparator.comparing;
+
+public class ComparatorExample {
+
+    public static void main(String[] args) {
+        List<Account> accounts = Accounts.getAccountList(10);
+        sortUsingAnonymousClass(accounts);
+        sortUsingLambda(accounts);
+        sortUsingMethodReference(accounts);
+    }
+
+    private static void sortUsingAnonymousClass(List<Account> accounts) {
+        accounts.sort(new Comparator<Account>() {
+            @Override
+            public int compare(Account o1, Account o2) {
+                return o1.getFirstName().compareTo(o2.getFirstName());
+            }
+        });
+    }
+
+    private static void sortUsingLambda(List<Account> accounts) {
+        accounts.sort((a1, a2) -> a1.getFirstName().compareTo(a2.getFirstName()));
+    }
+
+    private static void sortUsingMethodReference(List<Account> accounts) {
+        accounts.sort(comparing(Account::getFirstName));
+    }
+}

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

@@ -5,8 +5,6 @@
 
 import java.util.List;
 import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Supplier;
 
 /**
  * Method reference is a shorthand for lambda expression that could be use in some cases for better readability.
@@ -15,19 +13,19 @@ public class MethodReference {
     public static void main(String[] args) {
         List<Account> accounts = Accounts.getAccountList(10);
 
-        printAccountsWithLambda(accounts);
-        printAccountsWithMethodReference(accounts);
+        printAccountsUsingLambda(accounts);
+        printAccountsUsingMethodReference(accounts);
     }
 
-    private static void printAccountsWithLambda(List<Account> accounts) {
-        consumeAccounts(accounts, a -> System.out.println(a));
+    private static void printAccountsUsingLambda(List<Account> accounts) {
+        processAccounts(accounts, a -> System.out.println(a));
     }
 
-    private static void printAccountsWithMethodReference(List<Account> accounts) {
-        consumeAccounts(accounts, System.out::println); //todo: think what if you want to print only emails
+    private static void printAccountsUsingMethodReference(List<Account> accounts) {
+        processAccounts(accounts, System.out::println);
     }
 
-    private static void consumeAccounts(List<Account> accounts, Consumer<Account> consumer) {
+    private static void processAccounts(List<Account> accounts, Consumer<Account> consumer) {
         for (Account account : accounts){
             consumer.accept(account);
         }

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

@@ -0,0 +1,26 @@
+package com.bobocode;
+
+public class RunnableExample {
+    public static void main(String[] args) {
+        sayHelloFromNewThread();
+        sayHelloFromNewThreadUsingLambda();
+    }
+
+
+    private static void sayHelloFromNewThread() {
+        Runnable runnable = new Runnable() {
+            @Override
+            public void run() {
+                System.out.println("Hello from new Thread!");
+            }
+        };
+        Thread t = new Thread(runnable);
+        t.start();
+    }
+
+    private static void sayHelloFromNewThreadUsingLambda() {
+        Runnable runnable = () -> System.out.println("Hello Lambda!");
+        Thread t = new Thread(runnable);
+        t.start();
+    }
+}