- add OptionalCreation.java

- add OptionalImperativeVsDeclarativeCheck.java
- add OptionalStream.java
- refactored OptionalSearchByEmailExample.java and OptionalExamples.java

Author: Taras

Diff for: optional/src/main/java/com/bobocode/OptionalCreation.java

@@ -0,0 +1,18 @@
+package com.bobocode;
+
+import com.bobocode.data.Accounts;
+import com.bobocode.model.Account;
+
+import java.util.Optional;
+
+public class OptionalCreation {
+    public static void main(String[] args) {
+        Account account = Accounts.getAccount();
+
+        Optional<Account> optionalAccount = Optional.of(account);
+
+        Optional<Account> optionalNullableAccount = Optional.ofNullable(account);
+
+        Optional<Account> optionalEmptyAccount = Optional.empty();
+    }
+}

Diff for: optional/src/main/java/com/bobocode/OptionalExamples.java

@@ -4,44 +4,37 @@
 import com.bobocode.data.Accounts;
 import com.bobocode.model.Account;
 
-import java.util.List;
 import java.util.Optional;
 
-import static java.util.Comparator.comparing;
-
-public class OptionalExamples {
+public class  OptionalExamples {
     private static Account DEFAULT_ACCOUNT = Accounts.getAccount();
 
     public static void main(String[] args) {
-        List<Account> accounts = Accounts.getAccountList(10);
-        Optional<Account> optionalAccountWithMaxBalance = findAccountWithMaxBalance(accounts);
-
-        printAccountUsingWrongApproach(optionalAccountWithMaxBalance);
-        printAccountUsingRightApproach(optionalAccountWithMaxBalance);
+        Account account = Accounts.getAccount();
+        Optional<Account> optionalAccount = Optional.of(account);
 
-        printAccountOrDefault(optionalAccountWithMaxBalance);
-        printAccountOrRandomLazily(optionalAccountWithMaxBalance);
-    }
+        printAccountUsingWrongApproach(optionalAccount);
+        printAccountUsingRightApproach(optionalAccount);
 
-    private static Optional<Account> findAccountWithMaxBalance(List<Account> accounts) {
-        return accounts.stream().max(comparing(Account::getBalance));
+        printAccountOrDefault(optionalAccount);
+        printAccountOrRandomLazily(optionalAccount);
     }
 
     /**
      * It is not correct to process to process {@link Optional} values in the old imperative way, as it is shown below
      */
-    private static void printAccountUsingWrongApproach(Optional<Account> optionalAccountWithMaxBalance) {
-        if (optionalAccountWithMaxBalance.isPresent()) {
-            Account account = optionalAccountWithMaxBalance.get();
+    private static void printAccountUsingWrongApproach(Optional<Account> optionalAccount) {
+        if (optionalAccount.isPresent()) {
+            Account account = optionalAccount.get();
             System.out.println(account);
         }
     }
 
     /**
      * The right way is to pass a consumer that will be used in case {@link Optional} value is not empty
      */
-    private static void printAccountUsingRightApproach(Optional<Account> optionalAccountWithMaxBalance) {
-        optionalAccountWithMaxBalance.ifPresent(System.out::println);
+    private static void printAccountUsingRightApproach(Optional<Account> optionalAccount) {
+        optionalAccount.ifPresent(System.out::println);
     }
 
     /**

Diff for: optional/src/main/java/com/bobocode/OptionalImperativeVsDeclarativeCheck.java

@@ -0,0 +1,36 @@
+package com.bobocode;
+
+import com.bobocode.data.Accounts;
+import com.bobocode.model.Account;
+
+import java.util.Optional;
+
+public class OptionalImperativeVsDeclarativeCheck {
+    public static void main(String[] args) {
+        Account account = Accounts.getAccount();
+        Optional<Account> optionalAccount = Optional.of(account);
+
+        printAccount(account);
+        printOptionalAccount(optionalAccount);
+    }
+
+    /**
+     * An if statement is a classic example of imperative check
+     */
+    private static void printAccount(Account account) {
+        if (account != null) {
+            System.out.println(account);
+        } else {
+            System.out.println("No such element exists!");
+        }
+    }
+
+    /**
+     * This is an example of declarative check. You don't write an if statement yourself, it is performed inside the
+     * method ifPresentOrElse()
+     */
+    private static void printOptionalAccount(Optional<Account> optionalAccount) {
+        optionalAccount.ifPresentOrElse(System.out::println,
+                () -> System.out.println("No such element exists!"));
+    }
+}

Diff for: optional/src/main/java/com/bobocode/OptionalSearchByEmailExample.java

@@ -40,7 +40,8 @@ private static Account getAccountByEmailImperatively(List<Account> accounts, Str
     }
 
     private static void printAccount(Account account) {
-        System.out.println("This account belongs to " + account.getFirstName() + " " + account.getLastName());
+        System.out.println("This account belongs to " + account.getFirstName() +
+                " " + account.getLastName());
     }
 
     static class NoSuchElementException extends RuntimeException {

Diff for: optional/src/main/java/com/bobocode/OptionalStream.java

@@ -0,0 +1,31 @@
+package com.bobocode;
+
+import com.bobocode.data.Accounts;
+import com.bobocode.model.CreditAccount;
+
+import java.util.List;
+import java.util.Optional;
+
+public class OptionalStream {
+    public static void main(String[] args) {
+        List<CreditAccount> creditAccounts = Accounts.getCreditAccountsList(10);
+
+        printExistingCreditBalancesJava8(creditAccounts);
+        printExistingCreditBalancesJava9(creditAccounts);
+    }
+
+    private static void printExistingCreditBalancesJava8(List<CreditAccount> creditAccounts) {
+        creditAccounts.stream()
+                .map(CreditAccount::getCreditBalance)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .forEach(System.out::println);
+    }
+
+    private static void printExistingCreditBalancesJava9(List<CreditAccount> creditAccounts) {
+        creditAccounts.stream()
+                .map(CreditAccount::getCreditBalance)
+                .flatMap(Optional::stream)
+                .forEach(System.out::println);
+    }
+}