Completed solution

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

@@ -1,6 +1,7 @@
 package com.bobocode;
 
 import java.math.BigDecimal;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.Map;
 import java.util.function.*;
 
@@ -12,7 +13,7 @@ public class CrazyLambdas {
      * @return a string supplier
      */
     public static Supplier<String> helloSupplier() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return () -> "Hello";
     }
 
     /**
@@ -21,7 +22,7 @@ public static Supplier<String> helloSupplier() {
      * @return a string predicate
      */
     public static Predicate<String> isEmptyPredicate() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return String::isEmpty;
     }
 
     /**
@@ -31,7 +32,7 @@ public static Predicate<String> isEmptyPredicate() {
      * @return function that repeats Strings
      */
     public static BiFunction<String, Integer, String> stringMultiplier() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return String::repeat;
     }
 
     /**
@@ -41,7 +42,7 @@ public static BiFunction<String, Integer, String> stringMultiplier() {
      * @return function that converts adds dollar sign
      */
     public static Function<BigDecimal, String> toDollarStringFunction() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return bigDecimal -> "$" + bigDecimal;
     }
 
     /**
@@ -53,7 +54,7 @@ public static Function<BigDecimal, String> toDollarStringFunction() {
      * @return a string predicate
      */
     public static Predicate<String> lengthInRangePredicate(int min, int max) {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return str -> str.length() >= min && str.length() < max;
     }
 
     /**
@@ -62,7 +63,7 @@ public static Predicate<String> lengthInRangePredicate(int min, int max) {
      * @return int supplier
      */
     public static IntSupplier randomIntSupplier() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return () -> ThreadLocalRandom.current().nextInt();
     }
 
 
@@ -72,7 +73,7 @@ public static IntSupplier randomIntSupplier() {
      * @return int operation
      */
     public static IntUnaryOperator boundedRandomIntSupplier() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return bound -> ThreadLocalRandom.current().nextInt(bound);
     }
 
     /**
@@ -81,7 +82,7 @@ public static IntUnaryOperator boundedRandomIntSupplier() {
      * @return square operation
      */
     public static IntUnaryOperator intSquareOperation() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return a -> a * a;
     }
 
     /**
@@ -90,7 +91,7 @@ public static IntUnaryOperator intSquareOperation() {
      * @return binary sum operation
      */
     public static LongBinaryOperator longSumOperation() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return (a, b) -> a + b;
     }
 
     /**
@@ -99,7 +100,7 @@ public static LongBinaryOperator longSumOperation() {
      * @return string to int converter
      */
     public static ToIntFunction<String> stringToIntConverter() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return Integer::parseInt;
     }
 
     /**
@@ -110,7 +111,7 @@ public static ToIntFunction<String> stringToIntConverter() {
      * @return a function supplier
      */
     public static Supplier<IntUnaryOperator> nMultiplyFunctionSupplier(int n) {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return () -> a -> n * a;
     }
 
     /**
@@ -119,7 +120,7 @@ public static Supplier<IntUnaryOperator> nMultiplyFunctionSupplier(int n) {
      * @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
+        return stringFunction -> stringFunction.compose(String::trim);
     }
 
     /**
@@ -130,7 +131,11 @@ public static UnaryOperator<Function<String, String>> composeWithTrimFunction()
      * @return a thread supplier
      */
     public static Supplier<Thread> runningThreadSupplier(Runnable runnable) {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return () -> {
+            Thread thread = new Thread(runnable);
+            thread.start();
+            return thread;
+        };
     }
 
     /**
@@ -139,7 +144,7 @@ public static Supplier<Thread> runningThreadSupplier(Runnable runnable) {
      * @return a runnable consumer
      */
     public static Consumer<Runnable> newThreadRunnableConsumer() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return runnable -> new Thread(runnable).start();
     }
 
     /**
@@ -149,7 +154,11 @@ public static Consumer<Runnable> newThreadRunnableConsumer() {
      * @return a function that transforms runnable into a thread supplier
      */
     public static Function<Runnable, Supplier<Thread>> runnableToThreadSupplierFunction() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return runnable -> () -> {
+            Thread thread = new Thread(runnable);
+            thread.start();
+            return thread;
+        };
     }
 
     /**
@@ -162,7 +171,7 @@ public static Function<Runnable, Supplier<Thread>> runnableToThreadSupplierFunct
      * @return a binary function that receiver predicate and function and compose them to create a new function
      */
     public static BiFunction<IntUnaryOperator, IntPredicate, IntUnaryOperator> functionToConditionalFunction() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return (intOperation, intPredicate) -> a -> intPredicate.test(a) ? intOperation.applyAsInt(a) : a;
     }
 
     /**
@@ -173,7 +182,7 @@ public static BiFunction<IntUnaryOperator, IntPredicate, IntUnaryOperator> funct
      * @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
+        return (functionMap, functionName) -> functionMap.getOrDefault(functionName, IntUnaryOperator.identity());
     }
 
     /**
@@ -182,7 +191,8 @@ public static BiFunction<Map<String, IntUnaryOperator>, String, IntUnaryOperator
      * @return a supplier instance
      */
     public static Supplier<Supplier<Supplier<String>>> trickyWellDoneSupplier() {
-        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+        return () -> () -> () -> "WELL DONE!";
     }
 }
 
+

crazy-optionals/src/main/java/com/bobocode/CrazyOptionals.java

@@ -15,6 +15,8 @@
 import java.util.Optional;
 import java.util.OptionalDouble;
 
+import static java.util.Comparator.comparing;
+
 public class CrazyOptionals {
 
     /**
@@ -24,7 +26,7 @@ public class CrazyOptionals {
      * @return optional object that holds text
      */
     public static Optional<String> optionalOfString(@Nullable String text) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return Optional.ofNullable(text); // Optional.ofNullable() will use Optional.empty() if text is null
     }
 
     /**
@@ -34,7 +36,10 @@ public static Optional<String> optionalOfString(@Nullable String text) {
      * @param amount          money to deposit
      */
     public static void deposit(AccountProvider accountProvider, BigDecimal amount) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        accountProvider.getAccount()
+                .ifPresent(account -> account.setBalance(account.getBalance().add(amount))); // instead of using if operator
+        // you can pass Consumer object that will be used in case Optional is not empty
+        // this approach is called declarative and is usually more precise
     }
 
     /**
@@ -44,7 +49,7 @@ public static void deposit(AccountProvider accountProvider, BigDecimal amount) {
      * @return optional object that holds account
      */
     public static Optional<Account> optionalOfAccount(@Nonnull Account account) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return Optional.of(account); // Optional.of() will throw NullPointerException if account is null
     }
 
     /**
@@ -56,7 +61,8 @@ public static Optional<Account> optionalOfAccount(@Nonnull Account account) {
      * @return account from provider or defaultAccount
      */
     public static Account getAccount(AccountProvider accountProvider, Account defaultAccount) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .orElse(defaultAccount); // Optional#orElse() can be used to provide default value is case Optional is empty
     }
 
     /**
@@ -67,7 +73,10 @@ public static Account getAccount(AccountProvider accountProvider, Account defaul
      * @param accountService
      */
     public static void processAccount(AccountProvider accountProvider, AccountService accountService) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        accountProvider.getAccount()
+                .ifPresentOrElse(accountService::processAccount, accountService::processWithNoAccount);
+        // one more declarative substitution of if-else operator.
+        // Please note its parameters: Consumer and Runnable
     }
 
     /**
@@ -78,7 +87,12 @@ public static void processAccount(AccountProvider accountProvider, AccountServic
      * @return provided or generated account
      */
     public static Account getOrGenerateAccount(AccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .orElseGet(Accounts::generateAccount); // functionally it works exactly the same as Optional#orElse()
+        // however it is based on lazy initialization using Supplier interface, which means that default value
+        // will not be computed (created) until Supplier#get() is called, which means it will be only computed
+        // when Optional is empty. This method should be used in favor of Optional#orElse() when the creation of default
+        // value requires additional resources
     }
 
     /**
@@ -88,7 +102,8 @@ public static Account getOrGenerateAccount(AccountProvider accountProvider) {
      * @return optional balance
      */
     public static Optional<BigDecimal> retrieveBalance(AccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .map(Account::getBalance); // a null-safe mapping that allows you to go from Optional object to its field
     }
 
     /**
@@ -99,7 +114,9 @@ public static Optional<BigDecimal> retrieveBalance(AccountProvider accountProvid
      * @return provided account
      */
     public static Account getAccount(AccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .orElseThrow(() -> new AccountNotFoundException("No Account provided!")); // in case Optional is empty
+        // it allows to throw a custom exception
     }
 
     /**
@@ -109,7 +126,9 @@ public static Account getAccount(AccountProvider accountProvider) {
      * @return optional credit balance
      */
     public static Optional<BigDecimal> retrieveCreditBalance(CreditAccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .flatMap(CreditAccount::getCreditBalance); // in case your getter already return Optional, you cannot use
+        // Optional#map() because it will create Optional<Optional<Account>>. In this case Optional#flatMap() should be used
     }
 
 
@@ -121,7 +140,10 @@ public static Optional<BigDecimal> retrieveCreditBalance(CreditAccountProvider a
      * @return optional gmail account
      */
     public static Optional<Account> retrieveAccountGmail(AccountProvider accountProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .filter(account -> account.getEmail().split("@")[1].equals("gmail.com"));
+        // in case you need to check if an Optional Account meets some criteria and return it or if it does not
+        // then return Optional.empty() and do that in a null-safe manner
     }
 
     /**
@@ -134,7 +156,9 @@ public static Optional<Account> retrieveAccountGmail(AccountProvider accountProv
      * @return account got from either accountProvider or fallbackProvider
      */
     public static Account getAccountWithFallback(AccountProvider accountProvider, AccountProvider fallbackProvider) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accountProvider.getAccount()
+                .or(fallbackProvider::getAccount) // allows to use another Optional in case main Optional is empty
+                .orElseThrow(); // if both providers return Optional.empty() it throws NoSuchElementException
     }
 
     /**
@@ -145,7 +169,9 @@ public static Account getAccountWithFallback(AccountProvider accountProvider, Ac
      * @return account with the highest balance
      */
     public static Account getAccountWithMaxBalance(List<Account> accounts) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accounts.stream()
+                .max(comparing(Account::getBalance)) // as you probably know Stream#min() and Stream#max() return Optional
+                .orElseThrow();
     }
 
     /**
@@ -155,7 +181,10 @@ public static Account getAccountWithMaxBalance(List<Account> accounts) {
      * @return the lowest balance values
      */
     public static OptionalDouble findMinBalanceValue(List<Account> accounts) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accounts.stream()
+                .map(Account::getBalance) // map all stream accounts to balances
+                .mapToDouble(BigDecimal::doubleValue) // map all balances to primitive double values (returns DoubleStream)
+                .min(); // Optional API provides special classes for primitives as well
     }
 
     /**
@@ -165,7 +194,10 @@ public static OptionalDouble findMinBalanceValue(List<Account> accounts) {
      * @param accountService
      */
     public static void processAccountWithMaxBalance(List<Account> accounts, AccountService accountService) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        accounts.stream()
+                .max(comparing(Account::getBalance)) // returns Optional account
+                .ifPresent(accountService::processAccount); // declarative if statement and processing
+        // the last method requires Consumer<Account> as argument, it is implements using method reference
     }
 
     /**
@@ -175,7 +207,11 @@ public static void processAccountWithMaxBalance(List<Account> accounts, AccountS
      * @return total credit balance
      */
     public static double calculateTotalCreditBalance(List<CreditAccount> accounts) {
-        throw new UnsupportedOperationException("Some people say that method does not work until you implement it");
+        return accounts.stream()
+                .map(CreditAccount::getCreditBalance) // transforms each element of stream into Optional<BigDecimal>
+                .flatMap(Optional::stream) // uses special Optional#stream() to filter all elements that are empty
+                .mapToDouble(BigDecimal::doubleValue) // transform BigDecimal into primitive double (returns DoubleStream)
+                .sum(); // calculates a sum of primitive double
     }
 }