Merge remote-tracking branch 'Baeldung/master' into active_mq

# Conflicts:
#	.gitignore
#	LICENSE
#	README.md
#	core-java-modules/README.md
#	core-java-modules/core-java-11/README.md
#	core-java-modules/core-java-11/pom.xml
#	core-java-modules/core-java-8/README.md
#	core-java-modules/core-java-8/pom.xml
#	core-java-modules/core-java-8/src/main/resources/logback.xml
#	core-java-modules/core-java-annotations/README.md
#	core-java-modules/core-java-annotations/pom.xml
#	core-java-modules/core-java-collections-2/README.md
#	core-java-modules/core-java-collections-2/pom.xml
#	core-java-modules/core-java-collections-3/README.md
#	core-java-modules/core-java-collections-3/pom.xml
#	core-java-modules/core-java-collections-conversions-2/README.md
#	core-java-modules/core-java-collections-conversions-2/pom.xml
#	core-java-modules/core-java-collections-conversions/README.md
#	core-java-modules/core-java-collections-conversions/pom.xml
#	core-java-modules/core-java-collections-list/README.md
#	core-java-modules/core-java-collections-list/pom.xml
#	core-java-modules/core-java-collections/pom.xml
#	core-java-modules/core-java-datetime-conversion/README.md
#	core-java-modules/core-java-datetime-conversion/pom.xml
#	core-java-modules/core-java-datetime-conversion/src/test/java/com/baeldung/datetime/ConvertInstantToTimestampUnitTest.java
#	core-java-modules/core-java-io-2/pom.xml
#	core-java-modules/core-java-io/README.md
#	core-java-modules/core-java-io/pom.xml
#	core-java-modules/core-java-io/src/test/resources/fileTest.txt
#	core-java-modules/core-java-io/src/test/resources/sampleTextFile.txt
#	core-java-modules/core-java-lambdas/README.md
#	core-java-modules/core-java-lambdas/pom.xml
#	core-java-modules/core-java-serialization/pom.xml
#	core-java-modules/core-java-streams/README.md
#	core-java-modules/core-java-streams/pom.xml
#	core-java-modules/core-java-strings/README.md
#	core-java-modules/core-java-strings/pom.xml
#	core-java-modules/core-java-strings/src/test/resources/stringtoolong.txt
#	core-java-modules/core-java-uuid/README.md
#	core-java-modules/core-java-uuid/pom.xml
#	core-java-modules/pom.xml
#	image-processing/README.md
#	image-processing/pom.xml
#	image-processing/src/main/java/com/baeldung/imageprocessing/addingtext/AddText.java
#	image-processing/src/main/java/com/baeldung/imageprocessing/opencv/CameraStream.java
#	jackson-modules/jackson-annotations/README.md
#	jackson-modules/jackson-annotations/pom.xml
#	jackson-modules/jackson-conversions-2/README.md
#	jackson-modules/jackson-conversions-2/pom.xml
#	jackson-modules/jackson-conversions/README.md
#	jackson-modules/jackson-conversions/pom.xml
#	jackson-modules/jackson-custom-conversions/README.md
#	jackson-modules/jackson-custom-conversions/pom.xml
#	jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/defaultserializercustomserializer/CallingDefaultSerializerUnitTest.java
#	jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/deserialization/CustomDeserializationUnitTest.java
#	jackson-modules/jackson-exceptions/README.md
#	jackson-modules/jackson-exceptions/pom.xml
#	jackson-modules/jackson-exceptions/src/test/java/com/baeldung/exceptions/JacksonExceptionsUnitTest.java
#	jackson-modules/jackson-exceptions/src/test/java/com/baeldung/mappingexception/JacksonMappingExceptionUnitTest.java
#	jackson-modules/pom.xml
#	parent-boot-1/pom.xml
#	parent-boot-2/pom.xml
#	parent-boot-3/pom.xml
#	patterns-modules/design-patterns-architectural/pom.xml
#	patterns-modules/design-patterns-architectural/src/main/java/com/baeldung/repositoryvsdaopattern/UserDaoImpl.java
#	patterns-modules/design-patterns-behavioral-2/README.md
#	patterns-modules/design-patterns-behavioral-2/pom.xml
#	patterns-modules/design-patterns-creational-2/README.md
#	patterns-modules/design-patterns-creational-2/pom.xml
#	patterns-modules/design-patterns-singleton/README.md
#	patterns-modules/design-patterns-structural/src/main/resources/log4jstructuraldp.properties
#	patterns-modules/enterprise-patterns/pom.xml
#	patterns-modules/intercepting-filter/pom.xml
#	patterns-modules/pom.xml
#	persistence-modules/activejdbc/pom.xml
#	persistence-modules/hibernate5/README.md
#	persistence-modules/hibernate5/pom.xml
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/CustomInterceptor.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/entity/User.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/namingstrategy/CustomPhysicalNamingStrategy.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/Customer.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/HashMapConverter.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryIdClass.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryPK.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/IdentifiersIntegrationTest.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/bootstrap/BootstrapAPIIntegrationTest.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/proxy/HibernateProxyUnitTest.java
#	persistence-modules/hibernate5/src/test/resources/hibernate-interceptors.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-lifecycle.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-namingstrategy.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-persistjson.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate.properties
#	persistence-modules/pom.xml
#	persistence-modules/spring-data-jpa-crud/pom.xml
#	persistence-modules/spring-data-jpa-crud/src/main/java/com/baeldung/repository/FruitRepository.java
#	persistence-modules/spring-data-jpa-repo-2/README.md
#	persistence-modules/spring-data-jpa-repo-2/pom.xml
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/model/User.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/repository/CustomUserRepositoryImpl.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/saveperformance/Book.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/resources/application.properties
#	persistence-modules/spring-data-mongodb-reactive/pom.xml
#	persistence-modules/spring-data-redis/README.md
#	persistence-modules/spring-data-redis/pom.xml
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/reactive/redis/config/RedisConfig.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/config/RedisConfig.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/model/Student.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/queue/RedisMessageSubscriber.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisKeyCommandsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateListOpsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateValueOpsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/redis/repo/StudentRepositoryManualTest.java
#	pom.xml
#	testing-modules/assertion-libraries/README.md
#	testing-modules/assertion-libraries/pom.xml
#	testing-modules/junit-5-basics/README.md
#	testing-modules/junit-5-basics/pom.xml
#	testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Helper.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Main.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Helper.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Main.java
#	testing-modules/mockito-2/src/test/java/com/baeldung/nullmatcher/MainUnitTest.java
#	testing-modules/mockito-2/src/test/java/com/baeldung/wantedbutnotinvocked/MainUnitTest.java
#	testing-modules/pom.xml
#	testing-modules/spring-mockito/pom.xml
#	web-modules/dropwizard/pom.xml
#	web-modules/jakarta-ee/README.md
#	web-modules/jakarta-ee/pom.xml
#	web-modules/jakarta-ee/src/test/java/com/baeldung/eclipse/krazo/UserControllerUnitTest.java
#	web-modules/java-lite/pom.xml
#	web-modules/javax-servlets-2/README.md
#	web-modules/javax-servlets-2/pom.xml
#	web-modules/javax-servlets/pom.xml
#	web-modules/jee-7/pom.xml
#	web-modules/jooby/pom.xml
#	web-modules/ninja/pom.xml
#	web-modules/pom.xml
#	web-modules/ratpack/pom.xml
#	web-modules/resteasy/pom.xml
#	web-modules/restx/pom.xml
#	web-modules/spark-java/pom.xml
#	web-modules/vraptor/pom.xml
#	xml/README.md
#	xml/pom.xml
#	xml/src/main/resources/customer-binding.xml
#	xml/src/main/resources/sax/baeldung.xml
#	xml/src/test/resources/example_default_parser.xml
#	xml/src/test/resources/example_dom4j.xml
#	xml/src/test/resources/example_jaxb.xml
#	xml/src/test/resources/example_jaxen.xml
#	xml/src/test/resources/example_jdom.xml
#	xml/src/test/resources/example_stax.xml
#	xml/src/test/resources/sax/baeldung.xml
#	xml/src/test/resources/xml/websites.xml
#	xml/src/test/resources/xml/xee_attribute.xml

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/anonymousclass/EmailSenderService.java

@@ -0,0 +1,10 @@
+package com.baeldung.anonymousclass;
+
+public class EmailSenderService implements SenderService {
+
+    @Override
+    public String callSender(Sender sender) {
+        return sender.send("Email Notification");
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/anonymousclass/Sender.java

@@ -0,0 +1,7 @@
+package com.baeldung.anonymousclass;
+
+public interface Sender {
+
+    String send(final String message);
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/anonymousclass/SenderService.java

@@ -0,0 +1,7 @@
+package com.baeldung.anonymousclass;
+
+public interface SenderService {
+
+    String callSender(Sender sender);
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/anonymousclass/SmsSenderService.java

@@ -0,0 +1,10 @@
+package com.baeldung.anonymousclass;
+
+public class SmsSenderService implements SenderService {
+
+    @Override
+    public String callSender(Sender sender) {
+        return sender.send("SMS Notification");
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/Computer.java

@@ -0,0 +1,85 @@
+package com.baeldung.doublecolon;
+
+public class Computer {
+
+    private Integer age;
+    private String color;
+    private Integer healty;
+
+    Computer(final int age, final String color) {
+        this.age = age;
+        this.color = color;
+    }
+
+    Computer(final Integer age, final String color, final Integer healty) {
+        this.age = age;
+        this.color = color;
+        this.healty = healty;
+    }
+
+    public Computer() {
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public void setAge(final Integer age) {
+        this.age = age;
+    }
+
+    String getColor() {
+        return color;
+    }
+
+    public void setColor(final String color) {
+        this.color = color;
+    }
+
+    Integer getHealty() {
+        return healty;
+    }
+
+    void setHealty(final Integer healty) {
+        this.healty = healty;
+    }
+
+    public void turnOnPc() {
+        System.out.println("Computer turned on");
+    }
+
+    public void turnOffPc() {
+        System.out.println("Computer turned off");
+    }
+
+    public Double calculateValue(Double initialValue) {
+        return initialValue / 1.50;
+    }
+
+    @Override
+    public String toString() {
+        return "Computer{" + "age=" + age + ", color='" + color + '\'' + ", healty=" + healty + '}';
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        final Computer computer = (Computer) o;
+
+        return (age != null ? age.equals(computer.age) : computer.age == null) && (color != null ? color.equals(computer.color) : computer.color == null);
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = age != null ? age.hashCode() : 0;
+        result = 31 * result + (color != null ? color.hashCode() : 0);
+        return result;
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/ComputerUtils.java

@@ -0,0 +1,27 @@
+package com.baeldung.doublecolon;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.baeldung.doublecolon.function.ComputerPredicate;
+
+public class ComputerUtils {
+
+    static final ComputerPredicate after2010Predicate = (c) -> (c.getAge() > 2010);
+    static final ComputerPredicate blackPredicate = (c) -> "black".equals(c.getColor());
+
+    public static List<Computer> filter(final List<Computer> inventory, final ComputerPredicate p) {
+
+        final List<Computer> result = new ArrayList<>();
+        inventory.stream().filter(p::filter).forEach(result::add);
+
+        return result;
+    }
+
+    static void repair(final Computer computer) {
+        if (computer.getHealty() < 50) {
+            computer.setHealty(100);
+        }
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/MacbookPro.java

@@ -0,0 +1,39 @@
+package com.baeldung.doublecolon;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.function.Function;
+
+public class MacbookPro extends Computer {
+
+    private static final Logger LOG = LoggerFactory.getLogger(MacbookPro.class);
+
+    public MacbookPro(int age, String color) {
+        super(age, color);
+    }
+
+    MacbookPro(Integer age, String color, Integer healty) {
+        super(age, color, healty);
+    }
+
+    @Override
+    public void turnOnPc() {
+        LOG.debug("MacbookPro turned on");
+    }
+
+    @Override
+    public void turnOffPc() {
+        LOG.debug("MacbookPro turned off");
+    }
+
+    @Override
+    public Double calculateValue(Double initialValue) {
+
+        Function<Double, Double> function = super::calculateValue;
+        final Double pcValue = function.apply(initialValue);
+        LOG.debug("First value is:" + pcValue);
+        return pcValue + (initialValue / 10);
+
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/ComputerPredicate.java

@@ -0,0 +1,10 @@
+package com.baeldung.doublecolon.function;
+
+import com.baeldung.doublecolon.Computer;
+
+@FunctionalInterface
+public interface ComputerPredicate {
+
+    boolean filter(Computer c);
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/doublecolon/function/TriFunction.java

@@ -0,0 +1,15 @@
+package com.baeldung.doublecolon.function;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+@FunctionalInterface
+public interface TriFunction<A, B, C, R> {
+
+    R apply(A a, B b, C c);
+
+    default <V> TriFunction<A, B, C, V> andThen(final Function<? super R, ? extends V> after) {
+        Objects.requireNonNull(after);
+        return (final A a, final B b, final C c) -> after.apply(apply(a, b, c));
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/entity/Human.java

@@ -0,0 +1,89 @@
+package com.baeldung.java8.entity;
+
+public class Human {
+    private String name;
+    private int age;
+
+    public Human() {
+        super();
+    }
+
+    public Human(final String name, final int age) {
+        super();
+
+        this.name = name;
+        this.age = age;
+    }
+
+    // API
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(final int age) {
+        this.age = age;
+    }
+
+    // compare
+
+    public static int compareByNameThenAge(final Human lhs, final Human rhs) {
+        if (lhs.name.equals(rhs.name)) {
+            return Integer.compare(lhs.age, rhs.age);
+        } else {
+            return lhs.name.compareTo(rhs.name);
+        }
+    }
+
+    //
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + age;
+        result = prime * result + ((name == null) ? 0 : name.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final Human other = (Human) obj;
+        if (age != other.age) {
+            return false;
+        }
+        if (name == null) {
+            if (other.name != null) {
+                return false;
+            }
+        } else if (!name.equals(other.name)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("Human [name=").append(name).append(", age=").append(age).append("]");
+        return builder.toString();
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java

@@ -0,0 +1,62 @@
+package com.baeldung.java8.lambda.exceptions;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.function.Consumer;
+
+public class LambdaExceptionWrappers {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(LambdaExceptionWrappers.class);
+
+    public static Consumer<Integer> lambdaWrapper(Consumer<Integer> consumer) {
+        return i -> {
+            try {
+                consumer.accept(i);
+            } catch (ArithmeticException e) {
+                LOGGER.error("Arithmetic Exception occurred.", e);
+            }
+        };
+    }
+
+    static <T, E extends Exception> Consumer<T> consumerWrapper(Consumer<T> consumer, Class<E> clazz) {
+        return i -> {
+            try {
+                consumer.accept(i);
+            } catch (Exception ex) {
+                try {
+                    E exCast = clazz.cast(ex);
+                    LOGGER.error("Exception occurred.", exCast);
+                } catch (ClassCastException ccEx) {
+                    throw ex;
+                }
+            }
+        };
+    }
+
+    public static <T> Consumer<T> throwingConsumerWrapper(ThrowingConsumer<T, Exception> throwingConsumer) {
+        return i -> {
+            try {
+                throwingConsumer.accept(i);
+            } catch (Exception ex) {
+                throw new RuntimeException(ex);
+            }
+        };
+    }
+
+    public static <T, E extends Exception> Consumer<T> handlingConsumerWrapper(ThrowingConsumer<T, E> throwingConsumer, Class<E> exceptionClass) {
+        return i -> {
+            try {
+                throwingConsumer.accept(i);
+            } catch (Exception ex) {
+                try {
+                    E exCast = exceptionClass.cast(ex);
+                    LOGGER.error("Exception occurred.", exCast);
+                } catch (ClassCastException ccEx) {
+                    throw new RuntimeException(ex);
+                }
+            }
+        };
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java

@@ -0,0 +1,8 @@
+package com.baeldung.java8.lambda.exceptions;
+
+@FunctionalInterface
+public interface ThrowingConsumer<T, E extends Exception> {
+
+    void accept(T t) throws E;
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/serialization/NotSerializableLambdaExpression.java

@@ -0,0 +1,8 @@
+package com.baeldung.java8.lambda.serialization;
+
+public class NotSerializableLambdaExpression {
+    public static Object getLambdaExpressionObject() {
+        Runnable r = () -> System.out.println("please serialize this message");
+        return r;
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/serialization/SerializableLambdaExpression.java

@@ -0,0 +1,10 @@
+package com.baeldung.java8.lambda.serialization;
+
+import java.io.Serializable;
+
+public class SerializableLambdaExpression {
+    public static Object getLambdaExpressionObject() {
+        Runnable r = (Runnable & Serializable) () -> System.out.println("please serialize this message");
+        return r;
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Bar.java

@@ -0,0 +1,16 @@
+package com.baeldung.java8.lambda.tips;
+
+
+@FunctionalInterface
+public interface Bar {
+
+    String method(String string);
+
+    default String defaultBar() {
+        return "Default String from Bar";
+    }
+
+    default String defaultCommon() {
+        return "Default Common from Bar";
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Baz.java

@@ -0,0 +1,16 @@
+package com.baeldung.java8.lambda.tips;
+
+
+@FunctionalInterface
+public interface Baz {
+
+    String method(String string);
+
+    default String defaultBaz() {
+        return "Default String from Baz";
+    }
+
+    default String defaultCommon(){
+        return "Default Common from Baz";
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Foo.java

@@ -0,0 +1,11 @@
+package com.baeldung.java8.lambda.tips;
+
+
+@FunctionalInterface
+public interface Foo {
+
+    String method(String string);
+
+    default void defaultMethod() {
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/FooExtended.java

@@ -0,0 +1,11 @@
+package com.baeldung.java8.lambda.tips;
+
+
+@FunctionalInterface
+public interface FooExtended extends Baz, Bar {
+
+    @Override
+    default String defaultCommon() {
+        return Bar.super.defaultCommon();
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/Processor.java

@@ -0,0 +1,12 @@
+package com.baeldung.java8.lambda.tips;
+
+import java.util.concurrent.Callable;
+import java.util.function.Supplier;
+
+public interface Processor {
+
+    String processWithCallable(Callable<String> c) throws Exception;
+
+    String processWithSupplier(Supplier<String> s);
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/ProcessorImpl.java

@@ -0,0 +1,20 @@
+package com.baeldung.java8.lambda.tips;
+
+
+import java.util.concurrent.Callable;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class ProcessorImpl implements Processor {
+
+    @Override
+    public String processWithCallable(Callable<String> c) throws Exception {
+        return c.call();
+    }
+
+    @Override
+    public String processWithSupplier(Supplier<String> s) {
+        return s.get();
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/java8/lambda/tips/UseFoo.java

@@ -0,0 +1,38 @@
+package com.baeldung.java8.lambda.tips;
+
+
+import java.util.function.Function;
+
+public class UseFoo {
+
+    private String value = "Enclosing scope value";
+
+    public String add(final String string, final Foo foo) {
+        return foo.method(string);
+    }
+
+    public String addWithStandardFI(final String string, final Function<String, String> fn) {
+        return fn.apply(string);
+    }
+
+    public String scopeExperiment() {
+        final Foo fooIC = new Foo() {
+            String value = "Inner class value";
+
+            @Override
+            public String method(final String string) {
+                return value;
+            }
+        };
+        final String resultIC = fooIC.method("");
+
+        final Foo fooLambda = parameter -> {
+            final String value = "Lambda value";
+            return this.value;
+        };
+        final String resultLambda = fooLambda.method("");
+
+        return "Results: resultIC = " + resultIC + ", resultLambda = " + resultLambda;
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/lambdas/LambdaVariables.java

@@ -0,0 +1,88 @@
+package com.baeldung.lambdas;
+
+import java.util.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Supplier;
+import java.util.stream.IntStream;
+
+/**
+ * Class with examples about working with capturing lambdas.
+ */
+public class LambdaVariables {
+
+    private volatile boolean run = true;
+    private int start = 0;
+
+    private ExecutorService executor = Executors.newFixedThreadPool(3);
+
+    public static void main(String[] args) {
+        new LambdaVariables().localVariableMultithreading();
+    }
+
+    Supplier<Integer> incrementer(int start) {
+        return () -> start; // can't modify start parameter inside the lambda
+    }
+
+    Supplier<Integer> incrementer() {
+        return () -> start++;
+    }
+
+    public void localVariableMultithreading() {
+        boolean run = true;
+        executor.execute(() -> {
+            while (run) {
+                // do operation
+            }
+        });
+        // commented because it doesn't compile, it's just an example of non-final local variables in lambdas
+        // run = false;
+    }
+
+    public void instanceVariableMultithreading() {
+        executor.execute(() -> {
+            while (run) {
+                // do operation
+            }
+        });
+
+        run = false;
+    }
+
+    /**
+     * WARNING: always avoid this workaround!!
+     */
+    public void workaroundSingleThread() {
+        int[] holder = new int[] { 2 };
+        IntStream sums = IntStream
+          .of(1, 2, 3)
+          .map(val -> val + holder[0]);
+
+        holder[0] = 0;
+
+        System.out.println(sums.sum());
+    }
+
+    /**
+     * WARNING: always avoid this workaround!!
+     */
+    public void workaroundMultithreading() {
+        int[] holder = new int[] { 2 };
+        Runnable runnable = () -> System.out.println(IntStream
+          .of(1, 2, 3)
+          .map(val -> val + holder[0])
+          .sum());
+
+        new Thread(runnable).start();
+
+        // simulating some processing
+        try {
+            Thread.sleep(new Random().nextInt(3) * 1000L);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        holder[0] = 0;
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/suppliercallable/data/User.java

@@ -0,0 +1,59 @@
+package com.baeldung.suppliercallable.data;
+
+import java.time.LocalDate;
+
+public class User {
+
+    private String name;
+    private String surname;
+    private LocalDate birthDate;
+    private Integer age;
+    private Boolean canDriveACar = false;
+
+    public User(String name, String surname, LocalDate birthDate) {
+        this.name = name;
+        this.surname = surname;
+        this.birthDate = birthDate;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getSurname() {
+        return surname;
+    }
+
+    public void setSurname(String surname) {
+        this.surname = surname;
+    }
+
+    public LocalDate getBirthDate() {
+        return birthDate;
+    }
+
+    public void setBirthDate(LocalDate birthDate) {
+        this.birthDate = birthDate;
+    }
+
+    public void setAge(Integer age) {
+        this.age = age;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public Boolean getCanDriveACar() {
+        return canDriveACar;
+    }
+
+    public void setCanDriveACar(Boolean canDriveACar) {
+        this.canDriveACar = canDriveACar;
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/suppliercallable/service/Service.java

@@ -0,0 +1,8 @@
+package com.baeldung.suppliercallable.service;
+
+import com.baeldung.suppliercallable.data.User;
+
+public interface Service {
+
+    User execute(User user);
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/suppliercallable/service/callable/AgeCalculatorCallable.java

@@ -0,0 +1,20 @@
+package com.baeldung.suppliercallable.service.callable;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.util.concurrent.Callable;
+
+public class AgeCalculatorCallable implements Callable<Integer> {
+
+    private final LocalDate birthDate;
+
+    @Override
+    public Integer call() throws Exception {
+        return Period.between(birthDate, LocalDate.now())
+          .getYears();
+    }
+
+    public AgeCalculatorCallable(LocalDate birthDate) {
+        this.birthDate = birthDate;
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/suppliercallable/service/callable/CallableServiceImpl.java

@@ -0,0 +1,31 @@
+package com.baeldung.suppliercallable.service.callable;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import com.baeldung.suppliercallable.data.User;
+import com.baeldung.suppliercallable.service.Service;
+
+public class CallableServiceImpl implements Service {
+
+    @Override
+    public User execute(User user) {
+        ExecutorService executorService = Executors.newCachedThreadPool();
+
+        try {
+            Future<Integer> ageFuture = executorService.submit(new AgeCalculatorCallable(user.getBirthDate()));
+            Integer age = ageFuture.get();
+            Future<Boolean> canDriveACarFuture = executorService.submit(new CarDriverValidatorCallable(age));
+            Boolean canDriveACar = canDriveACarFuture.get();
+            user.setAge(age);
+            user.setCanDriveACar(canDriveACar);
+        } catch (ExecutionException | InterruptedException e) {
+            throw new RuntimeException(e.getCause());
+        }
+
+        return user;
+    }
+
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/suppliercallable/service/callable/CarDriverValidatorCallable.java

@@ -0,0 +1,17 @@
+package com.baeldung.suppliercallable.service.callable;
+
+import java.util.concurrent.Callable;
+
+public class CarDriverValidatorCallable implements Callable<Boolean> {
+
+    private final Integer age;
+
+    @Override
+    public Boolean call() throws Exception {
+        return age > 18;
+    }
+
+    public CarDriverValidatorCallable(Integer age) {
+        this.age = age;
+    }
+}

core-java-modules/core-java-lambdas/src/main/java/com/baeldung/suppliercallable/service/supplier/SupplierServiceImpl.java

@@ -0,0 +1,26 @@
+package com.baeldung.suppliercallable.service.supplier;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import com.baeldung.suppliercallable.data.User;
+import com.baeldung.suppliercallable.service.Service;
+
+public class SupplierServiceImpl implements Service {
+    @Override
+    public User execute(User user) {
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        CompletableFuture<Integer> ageFut = CompletableFuture.supplyAsync(() -> Period.between(user.getBirthDate(), LocalDate.now())
+          .getYears(), executorService)
+          .exceptionally((throwable -> null));
+        CompletableFuture<Boolean> canDriveACarFut = ageFut.thenComposeAsync(age -> CompletableFuture.supplyAsync(() -> age > 18, executorService))
+          .exceptionally((ex) -> false);
+        user.setAge(ageFut.join());
+        user.setCanDriveACar(canDriveACarFut.join());
+        return user;
+    }
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/anonymousclass/AnonymousClassToLambdaIntegrationTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.anonymousclass;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class AnonymousClassToLambdaIntegrationTest {
+
+    @Test
+    public void whenPassingAnonymousClass_thenSuccess() {
+        final SenderService emailSenderService = new EmailSenderService();
+
+        final String emailNotif = emailSenderService.callSender(new Sender() {
+            @Override
+            public String send(String message) {
+                return message;
+            }
+        });
+
+        assertEquals(emailNotif, "Email Notification");
+    }
+
+    @Test
+    public void whenPassingLambdaExpression_thenSuccess() {
+        final SenderService smsSenderService = new SmsSenderService();
+
+        final String smsNotif = smsSenderService.callSender((String message) -> {
+            return message;
+        });
+
+        assertEquals(smsNotif, "SMS Notification");
+    }
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/doublecolon/ComputerUtilsUnitTest.java

@@ -0,0 +1,91 @@
+package com.baeldung.doublecolon;
+
+import com.baeldung.doublecolon.function.TriFunction;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.BiFunction;
+
+import static com.baeldung.doublecolon.ComputerUtils.*;
+
+public class ComputerUtilsUnitTest {
+
+    @Before
+    public void setup() {
+    }
+
+    @After
+    public void tearDown() {
+    }
+
+    @Test
+    public void testConstructorReference() {
+
+        Computer c1 = new Computer(2015, "white");
+        Computer c2 = new Computer(2009, "black");
+        Computer c3 = new Computer(2014, "black");
+
+        BiFunction<Integer, String, Computer> c4Function = Computer::new;
+        Computer c4 = c4Function.apply(2013, "white");
+        BiFunction<Integer, String, Computer> c5Function = Computer::new;
+        Computer c5 = c5Function.apply(2010, "black");
+        BiFunction<Integer, String, Computer> c6Function = Computer::new;
+        Computer c6 = c6Function.apply(2008, "black");
+
+        List<Computer> inventory = Arrays.asList(c1, c2, c3, c4, c5, c6);
+
+        List<Computer> blackComputer = filter(inventory, blackPredicate);
+        Assert.assertEquals("The black Computers are: ", blackComputer.size(), 4);
+
+        List<Computer> after2010Computer = filter(inventory, after2010Predicate);
+        Assert.assertEquals("The Computer bought after 2010 are: ", after2010Computer.size(), 3);
+
+        List<Computer> before2011Computer = filter(inventory, c -> c.getAge() < 2011);
+        Assert.assertEquals("The Computer bought before 2011 are: ", before2011Computer.size(), 3);
+
+        inventory.sort(Comparator.comparing(Computer::getAge));
+
+        Assert.assertEquals("Oldest Computer in inventory", c6, inventory.get(0));
+
+    }
+
+    @Test
+    public void testStaticMethodReference() {
+
+        Computer c1 = new Computer(2015, "white", 35);
+        Computer c2 = new Computer(2009, "black", 65);
+        TriFunction<Integer, String, Integer, Computer> c6Function = Computer::new;
+        Computer c3 = c6Function.apply(2008, "black", 90);
+
+        List<Computer> inventory = Arrays.asList(c1, c2, c3);
+        inventory.forEach(ComputerUtils::repair);
+
+        Assert.assertEquals("Computer repaired", new Integer(100), c1.getHealty());
+    }
+
+    @Test
+    public void testInstanceMethodArbitraryObjectParticularType() {
+
+        Computer c1 = new Computer(2015, "white", 35);
+        Computer c2 = new MacbookPro(2009, "black", 65);
+        List<Computer> inventory = Arrays.asList(c1, c2);
+        inventory.forEach(Computer::turnOnPc);
+
+    }
+
+    @Test
+    public void testSuperMethodReference() {
+
+        final TriFunction<Integer, String, Integer, MacbookPro> integerStringIntegerObjectTriFunction = MacbookPro::new;
+        final MacbookPro macbookPro = integerStringIntegerObjectTriFunction.apply(2010, "black", 100);
+        Double initialValue = 999.99;
+        final Double actualValue = macbookPro.calculateValue(initialValue);
+        Assert.assertEquals(766.659, actualValue, 0.0);
+    }
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/FunctionalInterfaceUnitTest.java

@@ -0,0 +1,187 @@
+package com.baeldung.functionalinterface;
+
+import com.google.common.util.concurrent.Uninterruptibles;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.*;
+
+public class FunctionalInterfaceUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(FunctionalInterfaceUnitTest.class);
+
+    @Test
+    public void whenPassingLambdaToComputeIfAbsent_thenTheValueGetsComputedAndPutIntoMap() {
+        Map<String, Integer> nameMap = new HashMap<>();
+        Integer value = nameMap.computeIfAbsent("John", String::length);
+
+        assertEquals(new Integer(4), nameMap.get("John"));
+        assertEquals(new Integer(4), value);
+    }
+
+    @Test
+    public void whenPassingMethodReferenceToComputeIfAbsent_thenTheValueGetsComputedAndPutIntoMap() {
+        Map<String, Integer> nameMap = new HashMap<>();
+        Integer value = nameMap.computeIfAbsent("John", String::length);
+
+        assertEquals(new Integer(4), nameMap.get("John"));
+        assertEquals(new Integer(4), value);
+    }
+
+    @Test
+    public void whenUsingCustomFunctionalInterfaceForPrimitives_thenCanUseItAsLambda() {
+
+        short[] array = { (short) 1, (short) 2, (short) 3 };
+        byte[] transformedArray = transformArray(array, s -> (byte) (s * 2));
+
+        byte[] expectedArray = { (byte) 2, (byte) 4, (byte) 6 };
+        assertArrayEquals(expectedArray, transformedArray);
+
+    }
+
+    @Test
+    public void whenUsingBiFunction_thenCanUseItToReplaceMapValues() {
+        Map<String, Integer> salaries = new HashMap<>();
+        salaries.put("John", 40000);
+        salaries.put("Freddy", 30000);
+        salaries.put("Samuel", 50000);
+
+        salaries.replaceAll((name, oldValue) -> name.equals("Freddy") ? oldValue : oldValue + 10000);
+
+        assertEquals(new Integer(50000), salaries.get("John"));
+        assertEquals(new Integer(30000), salaries.get("Freddy"));
+        assertEquals(new Integer(60000), salaries.get("Samuel"));
+    }
+
+    @Test
+    public void whenPassingLambdaToThreadConstructor_thenLambdaInferredToRunnable() {
+        Thread thread = new Thread(() -> LOG.debug("Hello From Another Thread"));
+        thread.start();
+    }
+
+    @Test
+    public void whenUsingSupplierToGenerateNumbers_thenCanUseItInStreamGenerate() {
+
+        int[] fibs = { 0, 1 };
+        Stream<Integer> fibonacci = Stream.generate(() -> {
+            int result = fibs[1];
+            int fib3 = fibs[0] + fibs[1];
+            fibs[0] = fibs[1];
+            fibs[1] = fib3;
+            return result;
+        });
+
+        List<Integer> fibonacci5 = fibonacci.limit(5)
+            .collect(Collectors.toList());
+
+        assertEquals(new Integer(1), fibonacci5.get(0));
+        assertEquals(new Integer(1), fibonacci5.get(1));
+        assertEquals(new Integer(2), fibonacci5.get(2));
+        assertEquals(new Integer(3), fibonacci5.get(3));
+        assertEquals(new Integer(5), fibonacci5.get(4));
+    }
+
+    @Test
+    public void whenUsingConsumerInForEach_thenConsumerExecutesForEachListElement() {
+        List<String> names = Arrays.asList("John", "Freddy", "Samuel");
+        names.forEach(name -> LOG.debug("Hello, " + name));
+    }
+
+    @Test
+    public void whenUsingBiConsumerInForEach_thenConsumerExecutesForEachMapElement() {
+        Map<String, Integer> ages = new HashMap<>();
+        ages.put("John", 25);
+        ages.put("Freddy", 24);
+        ages.put("Samuel", 30);
+
+        ages.forEach((name, age) -> LOG.debug(name + " is " + age + " years old"));
+    }
+
+    @Test
+    public void whenUsingPredicateInFilter_thenListValuesAreFilteredOut() {
+        List<String> names = Arrays.asList("Angela", "Aaron", "Bob", "Claire", "David");
+
+        List<String> namesWithA = names.stream()
+            .filter(name -> name.startsWith("A"))
+            .collect(Collectors.toList());
+
+        assertEquals(2, namesWithA.size());
+        assertTrue(namesWithA.contains("Angela"));
+        assertTrue(namesWithA.contains("Aaron"));
+    }
+
+    @Test
+    public void whenUsingUnaryOperatorWithReplaceAll_thenAllValuesInTheListAreReplaced() {
+        List<String> names = Arrays.asList("bob", "josh", "megan");
+
+        names.replaceAll(String::toUpperCase);
+
+        assertEquals("BOB", names.get(0));
+        assertEquals("JOSH", names.get(1));
+        assertEquals("MEGAN", names.get(2));
+    }
+
+    @Test
+    public void whenUsingBinaryOperatorWithStreamReduce_thenResultIsSumOfValues() {
+
+        List<Integer> values = Arrays.asList(3, 5, 8, 9, 12);
+
+        int sum = values.stream()
+            .reduce(0, (i1, i2) -> i1 + i2);
+
+        assertEquals(37, sum);
+
+    }
+
+    @Test
+    public void whenComposingTwoFunctions_thenFunctionsExecuteSequentially() {
+
+        Function<Integer, String> intToString = Object::toString;
+        Function<String, String> quote = s -> "'" + s + "'";
+
+        Function<Integer, String> quoteIntToString = quote.compose(intToString);
+
+        assertEquals("'5'", quoteIntToString.apply(5));
+
+    }
+
+    @Test
+    public void whenUsingSupplierToGenerateValue_thenValueIsGeneratedLazily() {
+
+        Supplier<Double> lazyValue = () -> {
+            Uninterruptibles.sleepUninterruptibly(1000, TimeUnit.MILLISECONDS);
+            return 9d;
+        };
+
+        double valueSquared = squareLazy(lazyValue);
+
+        assertEquals(81d, valueSquared, 0);
+
+    }
+
+    //
+
+    public double squareLazy(Supplier<Double> lazyValue) {
+        return Math.pow(lazyValue.get(), 2);
+    }
+
+    public byte[] transformArray(short[] array, ShortToByteFunction function) {
+        byte[] transformedArray = new byte[array.length];
+        for (int i = 0; i < array.length; i++) {
+            transformedArray[i] = function.applyAsByte(array[i]);
+        }
+        return transformedArray;
+    }
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/functionalinterface/ShortToByteFunction.java

@@ -0,0 +1,8 @@
+package com.baeldung.functionalinterface;
+
+@FunctionalInterface
+public interface ShortToByteFunction {
+
+    byte applyAsByte(short s);
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/Java8SortUnitTest.java

@@ -0,0 +1,210 @@
+package com.baeldung.java8;
+
+import com.baeldung.java8.entity.Human;
+import com.google.common.collect.Lists;
+import com.google.common.primitives.Ints;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.equalTo;
+
+public class Java8SortUnitTest {
+
+    // tests -
+
+    @Test
+    public final void givenPreLambda_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        Collections.sort(humans, new Comparator<Human>() {
+            @Override
+            public final int compare(final Human h1, final Human h2) {
+                return h1.getName().compareTo(h2.getName());
+            }
+        });
+
+        Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        humans.sort((final Human h1, final Human h2) -> h1.getName().compareTo(h2.getName()));
+
+        Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void givenLambdaShortForm_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName()));
+
+        Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12));
+        humans.sort((lhs, rhs) -> {
+            if (lhs.getName().equals(rhs.getName())) {
+                return Integer.compare(lhs.getAge(), rhs.getAge());
+            } else {
+                return lhs.getName().compareTo(rhs.getName());
+            }
+        });
+        Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test
+    public final void givenCompositionVerbose_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12));
+        final Comparator<Human> byName = (h1, h2) -> h1.getName().compareTo(h2.getName());
+        final Comparator<Human> byAge = (h1, h2) -> Ints.compare(h1.getAge(), h2.getAge());
+
+        humans.sort(byName.thenComparing(byAge));
+        Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test
+    public final void givenComposition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12));
+
+        humans.sort(Comparator.comparing(Human::getName).thenComparing(Human::getAge));
+        Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test
+    public final void whenSortingEntitiesByAge_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        humans.sort((h1, h2) -> Ints.compare(h1.getAge(), h2.getAge()));
+        Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test
+    public final void whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+        final Comparator<Human> comparator = (h1, h2) -> h1.getName().compareTo(h2.getName());
+
+        humans.sort(comparator.reversed());
+        Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test
+    public final void givenMethodDefinition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        humans.sort(Human::compareByNameThenAge);
+        Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void givenInstanceMethod_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        humans.sort(Comparator.comparing(Human::getName));
+        Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void givenStreamNaturalOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<String> letters = Lists.newArrayList("B", "A", "C");
+
+        final List<String> sortedLetters = letters.stream().sorted().collect(Collectors.toList());
+        Assert.assertThat(sortedLetters.get(0), equalTo("A"));
+    }
+
+    @Test
+    public final void givenStreamCustomOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+        final Comparator<Human> nameComparator = (h1, h2) -> h1.getName().compareTo(h2.getName());
+
+        final List<Human> sortedHumans = humans.stream().sorted(nameComparator).collect(Collectors.toList());
+        Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void givenStreamComparatorOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        final List<Human> sortedHumans = humans.stream().sorted(Comparator.comparing(Human::getName)).collect(Collectors.toList());
+        Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void givenStreamNaturalOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<String> letters = Lists.newArrayList("B", "A", "C");
+
+        final List<String> reverseSortedLetters = letters.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedLetters.get(0), equalTo("C"));
+    }
+
+    @Test
+    public final void givenStreamCustomOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+        final Comparator<Human> reverseNameComparator = (h1, h2) -> h2.getName().compareTo(h1.getName());
+
+        final List<Human> reverseSortedHumans = humans.stream().sorted(reverseNameComparator).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test
+    public final void givenStreamComparatorOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        final List<Human> reverseSortedHumans = humans.stream().sorted(Comparator.comparing(Human::getName, Comparator.reverseOrder())).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test(expected = NullPointerException.class)
+    public final void givenANullElement_whenSortingEntitiesByName_thenThrowsNPE() {
+        final List<Human> humans = Lists.newArrayList(null, new Human("Jack", 12));
+
+        humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName()));
+    }
+
+    @Test
+    public final void givenANullElement_whenSortingEntitiesByNameManually_thenMovesTheNullToLast() {
+        final List<Human> humans = Lists.newArrayList(null, new Human("Jack", 12), null);
+
+        humans.sort((h1, h2) -> {
+            if (h1 == null) return h2 == null ? 0 : 1;
+            else if (h2 == null) return -1;
+
+            return h1.getName().compareTo(h2.getName());
+        });
+
+        Assert.assertNotNull(humans.get(0));
+        Assert.assertNull(humans.get(1));
+        Assert.assertNull(humans.get(2));
+    }
+
+    @Test
+    public final void givenANullElement_whenSortingEntitiesByName_thenMovesTheNullToLast() {
+        final List<Human> humans = Lists.newArrayList(null, new Human("Jack", 12), null);
+
+        humans.sort(Comparator.nullsLast(Comparator.comparing(Human::getName)));
+
+        Assert.assertNotNull(humans.get(0));
+        Assert.assertNull(humans.get(1));
+        Assert.assertNull(humans.get(2));
+    }
+
+    @Test
+    public final void givenANullElement_whenSortingEntitiesByName_thenMovesTheNullToStart() {
+        final List<Human> humans = Lists.newArrayList(null, new Human("Jack", 12), null);
+
+        humans.sort(Comparator.nullsFirst(Comparator.comparing(Human::getName)));
+
+        Assert.assertNull(humans.get(0));
+        Assert.assertNull(humans.get(1));
+        Assert.assertNotNull(humans.get(2));
+    }
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.java8.lambda.exceptions;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+import static com.baeldung.java8.lambda.exceptions.LambdaExceptionWrappers.*;
+
+public class LambdaExceptionWrappersUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(LambdaExceptionWrappersUnitTest.class);
+
+    private List<Integer> integers;
+
+    @Before
+    public void init() {
+        integers = Arrays.asList(3, 9, 7, 0, 10, 20);
+    }
+
+    @Test
+    public void whenNoExceptionFromLambdaWrapper_thenSuccess() {
+        integers.forEach(lambdaWrapper(i -> LOG.debug("{}", 50 / i)));
+    }
+
+    @Test
+    public void whenNoExceptionFromConsumerWrapper_thenSuccess() {
+        integers.forEach(consumerWrapper(i -> LOG.debug("{}", 50 / i), ArithmeticException.class));
+    }
+
+    @Test(expected = RuntimeException.class)
+    public void whenExceptionFromThrowingConsumerWrapper_thenSuccess() {
+        integers.forEach(throwingConsumerWrapper(i -> writeToFile(i)));
+    }
+
+    @Test
+    public void whenNoExceptionFromHandlingConsumerWrapper_thenSuccess() {
+        integers.forEach(handlingConsumerWrapper(i -> writeToFile(i), IOException.class));
+    }
+
+    private void writeToFile(Integer i) throws IOException {
+        if (i == 0) {
+            throw new IOException(); // mock IOException
+        }
+    }
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/Bicycle.java

@@ -0,0 +1,34 @@
+package com.baeldung.java8.lambda.methodreference;
+
+public class Bicycle {
+
+    private String brand;
+    private Integer frameSize;
+
+    public Bicycle(String brand) {
+        this.brand = brand;
+        this.frameSize = 0;
+    }
+
+    public Bicycle(String brand, Integer frameSize) {
+        this.brand = brand;
+        this.frameSize = frameSize;
+    }
+
+    public String getBrand() {
+        return brand;
+    }
+
+    public void setBrand(String brand) {
+        this.brand = brand;
+    }
+
+    public Integer getFrameSize() {
+        return frameSize;
+    }
+
+    public void setFrameSize(Integer frameSize) {
+        this.frameSize = frameSize;
+    }
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/BicycleComparator.java

@@ -0,0 +1,13 @@
+package com.baeldung.java8.lambda.methodreference;
+
+import java.util.Comparator;
+
+public class BicycleComparator implements Comparator<Bicycle> {
+
+    @Override
+    public int compare(Bicycle a, Bicycle b) {
+        return a.getFrameSize()
+            .compareTo(b.getFrameSize());
+    }
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/methodreference/MethodReferenceUnitTest.java

@@ -0,0 +1,79 @@
+package com.baeldung.java8.lambda.methodreference;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiFunction;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MethodReferenceUnitTest {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(MethodReferenceUnitTest.class);
+
+    private static <T> void doNothingAtAll(Object... o) {
+    }
+
+    @Test
+    public void referenceToStaticMethod() {
+        List<String> messages = Arrays.asList("Hello", "Baeldung", "readers!");
+        messages.forEach(word -> StringUtils.capitalize(word));
+        messages.forEach(StringUtils::capitalize);
+    }
+
+    @Test
+    public void referenceToInstanceMethodOfParticularObject() {
+        BicycleComparator bikeFrameSizeComparator = new BicycleComparator();
+        createBicyclesList().stream()
+            .sorted((a, b) -> bikeFrameSizeComparator.compare(a, b));
+        createBicyclesList().stream()
+            .sorted(bikeFrameSizeComparator::compare);
+    }
+
+    @Test
+    public void referenceToInstanceMethodOfArbitratyObjectOfParticularType() {
+        List<Integer> numbers = Arrays.asList(5, 3, 50, 24, 40, 2, 9, 18);
+        numbers.stream()
+            .sorted((a, b) -> a.compareTo(b));
+        numbers.stream()
+            .sorted(Integer::compareTo);
+    }
+
+    @Test
+    public void referenceToConstructor() {
+        BiFunction<String, Integer, Bicycle> bikeCreator = (brand, frameSize) -> new Bicycle(brand, frameSize);
+        BiFunction<String, Integer, Bicycle> bikeCreatorMethodReference = Bicycle::new;
+        List<Bicycle> bikes = new ArrayList<>();
+        bikes.add(bikeCreator.apply("Giant", 50));
+        bikes.add(bikeCreator.apply("Scott", 20));
+        bikes.add(bikeCreatorMethodReference.apply("Trek", 35));
+        bikes.add(bikeCreatorMethodReference.apply("GT", 40));
+    }
+
+    @Test
+    public void referenceToConstructorSimpleExample() {
+        List<String> bikeBrands = Arrays.asList("Giant", "Scott", "Trek", "GT");
+        bikeBrands.stream()
+            .map(Bicycle::new)
+            .toArray(Bicycle[]::new);
+    }
+
+    @Test
+    public void limitationsAndAdditionalExamples() {
+        createBicyclesList().forEach(b -> LOGGER.debug("Bike brand is '{}' and frame size is '{}'", b.getBrand(), b.getFrameSize()));
+        createBicyclesList().forEach((o) -> MethodReferenceUnitTest.doNothingAtAll(o));
+    }
+
+    private List<Bicycle> createBicyclesList() {
+        List<Bicycle> bikes = new ArrayList<>();
+        bikes.add(new Bicycle("Giant", 50));
+        bikes.add(new Bicycle("Scott", 20));
+        bikes.add(new Bicycle("Trek", 35));
+        bikes.add(new Bicycle("GT", 40));
+        return bikes;
+    }
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/serialization/LambdaSerializationUnitTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.java8.lambda.serialization;
+
+import org.junit.Test;
+
+import java.io.*;
+import java.nio.file.Files;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import static org.junit.Assert.assertTrue;
+
+public class LambdaSerializationUnitTest {
+    @Test(expected = NotSerializableException.class)
+    public void givenRunnable_whenNoCapturing_thenSerializationFailed() throws IOException, ClassNotFoundException {
+        Object obj = NotSerializableLambdaExpression.getLambdaExpressionObject();
+        writeAndReadObject(obj, Runnable.class);
+    }
+
+    @Test
+    public void givenIntersectionType_whenNoCapturing_thenSerializationSuccess() throws IOException, ClassNotFoundException {
+        Object obj = SerializableLambdaExpression.getLambdaExpressionObject();
+        writeAndReadObject(obj, Runnable.class);
+    }
+
+    @Test
+    public void givenSerializableRunnable_whenNoCapturing_thenSerializationSuccess() throws IOException, ClassNotFoundException {
+        SerializableRunnable obj = () -> System.out.println("please serialize this message");
+        writeAndReadObject(obj, SerializableRunnable.class);
+    }
+
+    @Test
+    public void givenSerializableFunction_whenNoCapturing_thenSerializationSuccess() throws IOException, ClassNotFoundException {
+        SerializableFunction<String, String> obj = message -> String.format("Hello %s", message);
+        writeAndReadObject(obj, SerializableFunction.class);
+    }
+
+    @Test
+    public void givenSerializableConsumer_whenNoCapturing_thenSerializationSuccess() throws IOException, ClassNotFoundException {
+        SerializableConsumer<String> obj = message -> System.out.println(message);
+        writeAndReadObject(obj, SerializableConsumer.class);
+    }
+
+    @Test(expected = NotSerializableException.class)
+    public void givenSerializableConsumer_whenCapturingNotSerializable_thenSerializationFailed() throws IOException, ClassNotFoundException {
+        SerializableConsumer<String> obj = System.out::println;
+        writeAndReadObject(obj, SerializableConsumer.class);
+    }
+
+    private <T> void writeAndReadObject(Object obj, Class<T> clazz) throws IOException, ClassNotFoundException {
+        File file = Files.createTempFile("lambda", "ser").toFile();
+        try (
+                FileOutputStream fos = new FileOutputStream(file);
+                ObjectOutputStream oos = new ObjectOutputStream(fos)
+        ) {
+            oos.writeObject(obj);
+        }
+
+        try (
+                FileInputStream fis = new FileInputStream(file);
+                ObjectInputStream ois = new ObjectInputStream(fis)
+        ) {
+            Object newObj = ois.readObject();
+            boolean isInstance = clazz.isInstance(newObj);
+
+            assertTrue(isInstance);
+        }
+    }
+
+    interface SerializableRunnable extends Runnable, Serializable {
+    }
+
+    interface SerializableFunction<T, R> extends Function<T, R>, Serializable {
+    }
+
+    interface SerializableConsumer<T> extends Consumer<T>, Serializable {
+    }
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/java8/lambda/tips/Java8FunctionalInteracesLambdasUnitTest.java

@@ -0,0 +1,94 @@
+package com.baeldung.java8.lambda.tips;
+
+import com.baeldung.java8.lambda.tips.Foo;
+import com.baeldung.java8.lambda.tips.FooExtended;
+import com.baeldung.java8.lambda.tips.UseFoo;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.function.Function;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+public class Java8FunctionalInteracesLambdasUnitTest {
+
+    private UseFoo useFoo;
+
+    @Before
+    public void init() {
+        useFoo = new UseFoo();
+    }
+
+    @Test
+    public void functionalInterfaceInstantiation_whenReturnDefiniteString_thenCorrect() {
+        final Foo foo = parameter -> parameter + "from lambda";
+        final String result = useFoo.add("Message ", foo);
+
+        assertEquals("Message from lambda", result);
+    }
+
+    @Test
+    public void standardFIParameter_whenReturnDefiniteString_thenCorrect() {
+        final Function<String, String> fn = parameter -> parameter + "from lambda";
+        final String result = useFoo.addWithStandardFI("Message ", fn);
+
+        assertEquals("Message from lambda", result);
+    }
+
+    @Test
+    public void defaultMethodFromExtendedInterface_whenReturnDefiniteString_thenCorrect() {
+        final FooExtended fooExtended = string -> string;
+        final String result = fooExtended.defaultCommon();
+
+        assertEquals("Default Common from Bar", result);
+    }
+
+    @Test
+    public void lambdaAndInnerClassInstantiation_whenReturnSameString_thenCorrect() {
+        final Foo foo = parameter -> parameter + "from Foo";
+
+        final Foo fooByIC = new Foo() {
+            @Override
+            public String method(final String string) {
+                return string + "from Foo";
+            }
+        };
+
+        assertEquals(foo.method("Something "), fooByIC.method("Something "));
+    }
+
+    @Test
+    public void accessVariablesFromDifferentScopes_whenReturnPredefinedString_thenCorrect() {
+        assertEquals("Results: resultIC = Inner class value, resultLambda = Enclosing scope value", useFoo.scopeExperiment());
+    }
+
+    @Test
+    public void shorteningLambdas_whenReturnEqualsResults_thenCorrect() {
+        final Foo foo = parameter -> buildString(parameter);
+
+        final Foo fooHuge = parameter -> {
+            final String result = "Something " + parameter;
+            // many lines of code
+            return result;
+        };
+
+        assertEquals(foo.method("Something"), fooHuge.method("Something"));
+    }
+
+    private String buildString(final String parameter) {
+        final String result = "Something " + parameter;
+        // many lines of code
+        return result;
+    }
+
+    @Test
+    public void mutatingOfEffectivelyFinalVariable_whenNotEquals_thenCorrect() {
+        final int[] total = new int[1];
+        final Runnable r = () -> total[0]++;
+        r.run();
+
+        assertNotEquals(0, total[0]);
+    }
+
+}

core-java-modules/core-java-lambdas/src/test/java/com/baeldung/suppliercallable/CallableSupplierUnitTest.java

@@ -0,0 +1,64 @@
+package com.baeldung.suppliercallable;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import java.time.LocalDate;
+import java.time.Month;
+import org.junit.jupiter.api.Test;
+import com.baeldung.suppliercallable.data.User;
+import com.baeldung.suppliercallable.service.Service;
+import com.baeldung.suppliercallable.service.callable.CallableServiceImpl;
+import com.baeldung.suppliercallable.service.supplier.SupplierServiceImpl;
+
+public class CallableSupplierUnitTest {
+
+    @Test
+    void givenCallableService_whenUserIsAnAdult_thenCanDriveACar() {
+        User user = new User("Test", "Test", LocalDate.of(2000, Month.JANUARY, 19));
+        Service service = new CallableServiceImpl();
+        service.execute(user);
+        assertEquals(true, user.getCanDriveACar());
+    }
+
+    @Test
+    void givenCallableService_whenUserIsNotAnAdult_thenCannotDriveACar() {
+        User user = new User("Test", "Test", LocalDate.of(2010, Month.JANUARY, 19));
+        Service service = new CallableServiceImpl();
+        service.execute(user);
+        assertEquals(false, user.getCanDriveACar());
+    }
+
+    @Test
+    void givenCallableService_whenBirthDateIsNull_thenShouldThrowAnException() {
+        User user = new User("Test", "Test", null);
+        Service service = new CallableServiceImpl();
+        assertThrows(RuntimeException.class, () -> service.execute(user));
+    }
+
+    @Test
+    void givenSupplierService_whenUserIsAnAdult_thenCanDriveACar() {
+        User user = new User("Test", "Test", LocalDate.of(2000, Month.JANUARY, 19));
+        Service service = new SupplierServiceImpl();
+        service.execute(user);
+        assertEquals(true, user.getCanDriveACar());
+    }
+
+    @Test
+    void givenSupplierService_whenUserIsNotAnAdult_thenCannotDriveACar() {
+        User user = new User("Test", "Test", LocalDate.of(2010, Month.JANUARY, 19));
+        Service service = new SupplierServiceImpl();
+        service.execute(user);
+        assertEquals(false, user.getCanDriveACar());
+    }
+
+    @Test
+    void givenSupplierService_whenBirthDateIsNull_thenCannotDriveACarAndAgeIsNull() {
+        User user = new User("Test", "Test", null);
+        Service service = new SupplierServiceImpl();
+        service.execute(user);
+        assertEquals(false, user.getCanDriveACar());
+        assertNull(user.getBirthDate());
+    }
+
+}