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
2024-04-30 12:23:19 -04:00
parent c18eb6d2ed 8cabe509a5
commit a51b7b55d9
27985 changed files with 1594773 additions and 0 deletions
@@ -0,0 +1,9 @@
+package com.baeldung.aspect;
+
+public aspect ChangeCallsToCurrentTimeInMillisMethod {
+    long around():
+            call(public static native long java.lang.System.currentTimeMillis())
+                    && within(user.code.base.pckg.*) {
+        return 0;
+    }
+}
@@ -0,0 +1,14 @@
+package com.baeldung.java_8_features;
+
+public class Address {
+
+    private String street;
+
+    public String getStreet() {
+        return street;
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+}
@@ -0,0 +1,4 @@
+package com.baeldung.java_8_features;
+
+public class CustomException extends RuntimeException {
+}
@@ -0,0 +1,16 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class OptionalAddress {
+
+    private String street;
+
+    public Optional<String> getStreet() {
+        return Optional.ofNullable(street);
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+}
@@ -0,0 +1,16 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class OptionalUser {
+
+    private OptionalAddress address;
+
+    public Optional<OptionalAddress> getAddress() {
+        return Optional.of(address);
+    }
+
+    public void setAddress(OptionalAddress address) {
+        this.address = address;
+    }
+}
@@ -0,0 +1,40 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class User {
+
+    private String name;
+
+    private Address address;
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
+
+    public User() {
+    }
+
+    public User(String name) {
+        this.name = name;
+    }
+
+    public static boolean isRealUser(User user) {
+        return true;
+    }
+
+    public String getOrThrow() {
+        String value = null;
+        Optional<String> valueOpt = Optional.ofNullable(value);
+        String result = valueOpt.orElseThrow(CustomException::new).toUpperCase();
+        return result;
+    }
+
+    public boolean isLegalName(String name) {
+        return name.length() > 3 && name.length() < 16;
+    }
+}
@@ -0,0 +1,18 @@
+package com.baeldung.java_8_features;
+
+public interface Vehicle {
+
+    void moveTo(long altitude, long longitude);
+
+    static String producer() {
+        return "N&F Vehicles";
+    }
+
+    default long[] startPosition() {
+        return new long[] { 23, 15 };
+    }
+
+    default String getOverview() {
+        return "ATV made by " + producer();
+    }
+}
@@ -0,0 +1,9 @@
+package com.baeldung.java_8_features;
+
+public class VehicleImpl implements Vehicle {
+
+    @Override
+    public void moveTo(long altitude, long longitude) {
+        // do nothing
+    }
+}
@@ -0,0 +1,82 @@
+package com.baeldung.monad;
+
+import java.util.Optional;
+import java.util.function.Function;
+
+class MonadBaseExample {
+
+    public double multiplyBy2(double n) {
+        return n * 2;
+    }
+
+    public double divideBy2(double n) {
+        return n / 2;
+    }
+
+    public double add3(double n) {
+        return n + 3;
+    }
+
+    public double subtract1(double n) {
+        return n - 1;
+    }
+
+}
+
+class MonadSample1 extends MonadBaseExample {
+
+    public double apply(double n) {
+        return subtract1(add3(divideBy2(multiplyBy2(multiplyBy2(2)))));
+    }
+}
+
+class MonadSample2 extends MonadBaseExample {
+    public double apply(double n) {
+        double n1 = multiplyBy2(n);
+        double n2 = multiplyBy2(n1);
+        double n3 = divideBy2(n2);
+        double n4 = add3(n3);
+        return subtract1(n4);
+    }
+}
+
+class MonadSample3 extends MonadBaseExample {
+
+    public double apply(double n) {
+        return Optional.of(n)
+                .flatMap(value -> Optional.of(multiplyBy2(value)))
+                .flatMap(value -> Optional.of(multiplyBy2(value)))
+                .flatMap(value -> Optional.of(divideBy2(value)))
+                .flatMap(value -> Optional.of(add3(value)))
+                .flatMap(value -> Optional.of(subtract1(value)))
+                .get();
+    }
+
+}
+
+ class MonadSample4 extends MonadBaseExample {
+     public boolean leftIdentity() {
+         Function<Integer, Optional<Integer>> mapping = value -> Optional.of(value + 1);
+         return Optional.of(3).flatMap(mapping).equals(mapping.apply(3));
+     }
+
+     public boolean rightIdentity() {
+         return Optional.of(3).flatMap(Optional::of).equals(Optional.of(3));
+     }
+
+     public boolean associativity() {
+         Function<Integer, Optional<Integer>> mapping = value -> Optional.of(value + 1);
+         Optional<Integer> leftSide = Optional.of(3).flatMap(mapping).flatMap(Optional::of);
+         Optional<Integer> rightSide = Optional.of(3).flatMap(v -> mapping.apply(v).flatMap(Optional::of));
+         return leftSide.equals(rightSide);
+     }
+
+ }
+
+class MonadSample5 extends MonadBaseExample {
+    public boolean fail() {
+        Function<Integer, Optional<Integer>> mapping = value -> Optional.of(value == null ? -1 : value + 1);
+        return Optional.ofNullable((Integer) null).flatMap(mapping).equals(mapping.apply(null));
+    }
+}
+
@@ -0,0 +1,19 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+import static org.apache.commons.collections4.CollectionUtils.emptyIfNull;
+
+public class NullSafeCollectionStreamsUsingCommonsEmptyIfNull {
+
+    /**
+    * This method shows how to make a null safe stream from a collection through the use of 
+    * emptyIfNull() method from Apache Commons CollectionUtils library
+    * 
+     * @param collection The collection that is to be converted into a stream
+     * @return The stream that has been created from the collection or an empty stream if the collection is null
+    */
+    public Stream<String> collectionAsStream(Collection<String> collection) {
+        return emptyIfNull(collection).stream();
+    }
+}
@@ -0,0 +1,21 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class NullSafeCollectionStreamsUsingJava8OptionalContainer {
+
+    /**
+    * This method shows how to make a null safe stream from a collection  through the use of 
+    * Java SE 8’s Optional Container
+    * 
+     * @param collection The collection that is to be converted into a stream
+     * @return The stream that has been created from the collection or an empty stream if the collection is null
+    */
+    public Stream<String> collectionAsStream(Collection<String> collection) {
+        return Optional.ofNullable(collection)
+            .map(Collection::stream)
+            .orElseGet(Stream::empty);
+    }
+}
@@ -0,0 +1,20 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+
+public class NullSafeCollectionStreamsUsingNullDereferenceCheck {
+    
+    /**
+    * This method shows how to make a null safe stream from a collection through the use of a check 
+    * to prevent null dereferences
+    * 
+    * @param collection The collection that is to be converted into a stream
+    * @return The stream that has been created from the collection or an empty stream if the collection is null
+    */
+    public Stream<String> collectionAsStream(Collection<String> collection) {
+        return collection == null ? Stream.empty() : collection.stream();
+    }    
+
+
+}
@@ -0,0 +1,44 @@
+package com.baeldung.spliterator;
+
+import java.util.List;
+
+public class Article {
+    private List<Author> listOfAuthors;
+    private int id;
+    private String name;
+
+    public Article(String name) {
+        this.name = name;
+    }
+
+    public Article(List<Author> listOfAuthors, int id) {
+        super();
+        this.listOfAuthors = listOfAuthors;
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public List<Author> getListOfAuthors() {
+        return listOfAuthors;
+    }
+
+    public void setListOfAuthors(List<Author> listOfAuthors) {
+        this.listOfAuthors = listOfAuthors;
+    }
+
+}
@@ -0,0 +1,33 @@
+package com.baeldung.spliterator;
+
+public class Author {
+    private String name;
+    private int relatedArticleId;
+
+    public Author(String name, int relatedArticleId) {
+        this.name = name;
+        this.relatedArticleId = relatedArticleId;
+    }
+
+    public int getRelatedArticleId() {
+        return relatedArticleId;
+    }
+
+    public void setRelatedArticleId(int relatedArticleId) {
+        this.relatedArticleId = relatedArticleId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String toString() {
+        return "[name: " + name + ", relatedId: " + relatedArticleId + "]";
+    }
+}
+
@@ -0,0 +1,48 @@
+package com.baeldung.spliterator;
+
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+public class CustomSpliterator implements Spliterator<Integer> {
+    private final List<Integer> elements;
+    private int currentIndex;
+    
+    public CustomSpliterator(List<Integer> elements) {
+        this.elements = elements;
+        this.currentIndex = 0;
+    }
+    
+    @Override
+    public boolean tryAdvance(Consumer<? super Integer> action) {
+        if (currentIndex < elements.size()) {
+            action.accept(elements.get(currentIndex));
+            currentIndex++;
+            return true;
+        }
+        return false;
+    }
+    
+    @Override
+    public Spliterator<Integer> trySplit() {
+        int currentSize = elements.size() - currentIndex;
+        if (currentSize < 2) {
+            return null;
+        }
+        
+        int splitIndex = currentIndex + currentSize / 2;
+        CustomSpliterator newSpliterator = new CustomSpliterator(elements.subList(currentIndex, splitIndex));
+        currentIndex = splitIndex;
+        return newSpliterator;
+    }
+    
+    @Override
+    public long estimateSize() {
+        return elements.size() - currentIndex;
+    }
+    
+    @Override
+    public int characteristics() {
+        return ORDERED | SIZED | SUBSIZED | NONNULL;
+    }
+} 
@@ -0,0 +1,11 @@
+package com.baeldung.strategy;
+
+import java.math.BigDecimal;
+
+public class ChristmasDiscounter implements Discounter {
+
+    @Override
+    public BigDecimal apply(BigDecimal amount) {
+        return amount.multiply(BigDecimal.valueOf(0.9));
+    }
+}
@@ -0,0 +1,23 @@
+package com.baeldung.strategy;
+
+import java.math.BigDecimal;
+import java.util.function.UnaryOperator;
+
+public interface Discounter extends UnaryOperator<BigDecimal> {
+
+    default Discounter combine(Discounter after) {
+        return value -> after.apply(this.apply(value));
+    }
+
+    static Discounter christmas() {
+        return (amount) -> amount.multiply(BigDecimal.valueOf(0.9));
+    }
+
+    static Discounter newYear() {
+        return (amount) -> amount.multiply(BigDecimal.valueOf(0.8));
+    }
+
+    static Discounter easter() {
+        return (amount) -> amount.multiply(BigDecimal.valueOf(0.5));
+    }
+}
@@ -0,0 +1,11 @@
+package com.baeldung.strategy;
+
+import java.math.BigDecimal;
+
+public class EasterDiscounter implements Discounter {
+
+    @Override
+    public BigDecimal apply(BigDecimal amount) {
+        return amount.multiply(BigDecimal.valueOf(0.5));
+    }
+}
@@ -0,0 +1,110 @@
+package com.baeldung.internationalization;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.text.DateFormat;
+import java.text.DateFormatSymbols;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.TimeZone;
+
+public class DateFormatUnitTest {
+
+    @Test
+    public void givenGregorianCalendar_whenLocaleSpecificDateInstance_givenLanguageSpecificMonths() {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(2018, 1, 1, 10, 15, 20);
+        Date date = gregorianCalendar.getTime();
+
+        DateFormat itInstance = DateFormat.getDateInstance(DateFormat.FULL, Locale.ITALY);
+        DateFormat usInstance = DateFormat.getDateInstance(DateFormat.FULL, Locale.US);
+
+        Assert.assertEquals("giovedì 1 febbraio 2018", itInstance.format(date));
+        Assert.assertEquals("Thursday, February 1, 2018", usInstance.format(date));
+    }
+
+    @Test
+    public void givenGregorianCalendar_whenDateInstanceWithDifferentFormats_givenSpecificDateFormatting() {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(2018, 1, 1, 10, 15, 20);
+        Date date = gregorianCalendar.getTime();
+
+        DateFormat fullInstance = DateFormat.getDateInstance(DateFormat.FULL, Locale.ITALY);
+        DateFormat mediumInstance = DateFormat.getDateInstance(DateFormat.MEDIUM, Locale.ITALY);
+
+        Assert.assertEquals("giovedì 1 febbraio 2018", fullInstance.format(date));
+        Assert.assertEquals("1-feb-2018", mediumInstance.format(date));
+    }
+
+    @Test
+    public void givenGregorianCalendar_whenTimeInstanceWithDifferentFormats_givenSpecificTimeFormatting() {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(2018, 1, 1, 10, 15, 20);
+        gregorianCalendar.setTimeZone(TimeZone.getTimeZone("CET"));
+        TimeZone.setDefault(TimeZone.getTimeZone("CET"));
+        Date date = gregorianCalendar.getTime();
+
+        DateFormat fullInstance = DateFormat.getTimeInstance(DateFormat.FULL, Locale.ITALY);
+        DateFormat mediumInstance = DateFormat.getTimeInstance(DateFormat.MEDIUM, Locale.ITALY);
+
+        Assert.assertEquals("10.15.20 CET", fullInstance.format(date));
+        Assert.assertEquals("10.15.20" , mediumInstance.format(date));
+    }
+
+    @Test
+    public void givenGregorianCalendar_whenDateTimeInstanceWithDifferentFormats_givenSpecificDateTimeFormatting() {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(2018, 1, 1, 10, 15, 20);
+        gregorianCalendar.setTimeZone(TimeZone.getTimeZone("CET"));
+        TimeZone.setDefault(TimeZone.getTimeZone("CET"));
+        Date date = gregorianCalendar.getTime();
+
+        DateFormat ffInstance = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, Locale.ITALY);
+        DateFormat smInstance = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM, Locale.ITALY);
+
+        Assert.assertEquals("giovedì 1 febbraio 2018 10.15.20 CET", ffInstance.format(date));
+        Assert.assertEquals("01/02/18 10.15.20", smInstance.format(date));
+    }
+
+    @Test
+    public void givenGregorianCalendar_whenLocaleSpecificDateTimeInstance_givenLocaleSpecificFormatting() {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(2018, 1, 1, 10, 15, 20);
+        gregorianCalendar.setTimeZone(TimeZone.getTimeZone("CET"));
+        TimeZone.setDefault(TimeZone.getTimeZone("CET"));
+        Date date = gregorianCalendar.getTime();
+
+        DateFormat itInstance = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, Locale.ITALY);
+        DateFormat jpInstance = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, Locale.JAPAN);
+
+        Assert.assertEquals("giovedì 1 febbraio 2018 10.15.20 CET", itInstance.format(date));
+        Assert.assertEquals("2018年2月1日 10時15分20秒 CET", jpInstance.format(date));
+    }
+
+    @Test
+    public void givenGregorianCalendar_whenCustomizedSimpleDateFormat_thenSpecificMonthRepresentations() {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(2018, 1, 1, 10, 15, 20);
+        Date date = gregorianCalendar.getTime();
+        Locale.setDefault(new Locale("pl", "PL"));
+
+        SimpleDateFormat fullMonthDateFormat = new SimpleDateFormat("dd-MMMM-yyyy HH:mm:ss:SSS");
+        SimpleDateFormat shortMonthsimpleDateFormat = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss:SSS");
+
+        Assert.assertEquals("01-lutego-2018 10:15:20:000", fullMonthDateFormat.format(date));
+        Assert.assertEquals("01-02-2018 10:15:20:000" , shortMonthsimpleDateFormat.format(date));
+    }
+
+    @Test
+    public void givenGregorianCalendar_whenCustomizedDateFormatSymbols_thenChangedDayNames() {
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(2018, 1, 1, 10, 15, 20);
+        Date date = gregorianCalendar.getTime();
+        Locale.setDefault(new Locale("pl", "PL"));
+
+        DateFormatSymbols dateFormatSymbols = new DateFormatSymbols();
+        dateFormatSymbols.setWeekdays(new String[]{"A", "B", "C", "D", "E", "F", "G", "H"});
+        SimpleDateFormat standardDateFormat = new SimpleDateFormat("EEEE-MMMM-yyyy HH:mm:ss:SSS");
+        SimpleDateFormat newDaysDateFormat = new SimpleDateFormat("EEEE-MMMM-yyyy HH:mm:ss:SSS", dateFormatSymbols);
+
+        Assert.assertEquals("czwartek-lutego-2018 10:15:20:000", standardDateFormat.format(date));
+        Assert.assertEquals("F-lutego-2018 10:15:20:000", newDaysDateFormat.format(date));
+    }
+
+}
@@ -0,0 +1,76 @@
+package com.baeldung.internationalization;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.text.NumberFormat;
+import java.util.Currency;
+import java.util.Locale;
+
+public class NumbersCurrenciesFormattingUnitTest {
+
+    @Test
+    public void givenDifferentLocalesAndDoubleNumber_whenNumberInstance_thenDifferentOutput() {
+        Locale usLocale = Locale.US;
+        Locale plLocale = new Locale("pl", "PL");
+        Locale deLocale = Locale.GERMANY;
+        double number = 102_300.456d;
+
+        NumberFormat usNumberFormat = NumberFormat.getInstance(usLocale);
+        NumberFormat plNumberFormat = NumberFormat.getInstance(plLocale);
+        NumberFormat deNumberFormat = NumberFormat.getInstance(deLocale);
+
+        Assert.assertEquals(usNumberFormat.format(number), "102,300.456");
+        Assert.assertEquals(plNumberFormat.format(number), "102 300,456");
+        Assert.assertEquals(deNumberFormat.format(number), "102.300,456");
+    }
+
+    @Test
+    public void givenDifferentLocalesAndDoubleAmount_whenCurrencyInstance_thenDifferentOutput() {
+        Locale usLocale = Locale.US;
+        Locale plLocale = new Locale("pl", "PL");
+        Locale deLocale = Locale.GERMANY;
+        BigDecimal number = new BigDecimal(102_300.456d);
+
+        NumberFormat usNumberFormat = NumberFormat.getCurrencyInstance(usLocale);
+        NumberFormat plNumberFormat = NumberFormat.getCurrencyInstance(plLocale);
+        NumberFormat deNumberFormat = NumberFormat.getCurrencyInstance(deLocale);
+
+        Assert.assertEquals(usNumberFormat.format(number), "$102,300.46");
+        Assert.assertEquals(plNumberFormat.format(number), "102 300,46 zł");
+        Assert.assertEquals(deNumberFormat.format(number), "102.300,46 €");
+    }
+
+    @Test
+    public void givenLocaleAndNumber_whenSpecificDecimalFormat_thenSpecificOutput() {
+        Locale.setDefault(Locale.FRANCE);
+        BigDecimal number = new BigDecimal(102_300.456d);
+
+        DecimalFormat zeroDecimalFormat = new DecimalFormat("000000000.0000");
+        DecimalFormat hashDecimalFormat = new DecimalFormat("###,###.#");
+        DecimalFormat dollarDecimalFormat = new DecimalFormat("$###,###.##");
+
+        Assert.assertEquals(zeroDecimalFormat.format(number), "000102300,4560");
+        Assert.assertEquals(hashDecimalFormat.format(number), "102 300,5");
+        Assert.assertEquals(dollarDecimalFormat.format(number), "$102 300,46");
+    }
+
+    @Test
+    public void givenLocaleAndNumber_whenSpecificDecimalFormatSymbols_thenSpecificOutput() {
+        Locale.setDefault(Locale.FRANCE);
+        BigDecimal number = new BigDecimal(102_300.456d);
+
+        DecimalFormatSymbols decimalFormatSymbols = DecimalFormatSymbols.getInstance();
+        decimalFormatSymbols.setGroupingSeparator('^');
+        decimalFormatSymbols.setDecimalSeparator('@');
+        DecimalFormat separatorsDecimalFormat = new DecimalFormat("$###,###.##");
+        separatorsDecimalFormat.setGroupingSize(4);
+        separatorsDecimalFormat.setCurrency(Currency.getInstance(Locale.JAPAN));
+        separatorsDecimalFormat.setDecimalFormatSymbols(decimalFormatSymbols);
+
+        Assert.assertEquals(separatorsDecimalFormat.format(number), "$10^2300@46");
+    }
+}
@@ -0,0 +1,27 @@
+package com.baeldung.java8;
+
+import com.baeldung.java_8_features.Vehicle;
+import com.baeldung.java_8_features.VehicleImpl;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class Java8DefaultStaticIntefaceMethodsUnitTest {
+
+    @Test
+    public void callStaticInterfaceMethdosMethods_whenExpectedResults_thenCorrect() {
+        Vehicle vehicle = new VehicleImpl();
+        String overview = vehicle.getOverview();
+        long[] startPosition = vehicle.startPosition();
+
+        assertEquals(overview, "ATV made by N&F Vehicles");
+        assertEquals(startPosition[0], 23);
+        assertEquals(startPosition[1], 15);
+    }
+
+    @Test
+    public void callDefaultInterfaceMethods_whenExpectedResults_thenCorrect() {
+        String producer = Vehicle.producer();
+        assertEquals(producer, "N&F Vehicles");
+    }
+}
@@ -0,0 +1,111 @@
+package com.baeldung.java8;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.function.Consumer;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Java8ForEachUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(Java8ForEachUnitTest.class);
+
+    @Test
+    public void compareForEachMethods_thenPrintResults() {
+
+        List<String> names = new ArrayList<>();
+        names.add("Larry");
+        names.add("Steve");
+        names.add("James");
+        names.add("Conan");
+        names.add("Ellen");
+
+        // Java 5 - for-loop
+        LOG.debug("--- Enhanced for-loop ---");
+        for (String name : names) {
+            LOG.debug(name);
+        }
+
+        // Java 8 - forEach
+        names.forEach(name -> {
+            System.out.println(name);
+        });
+
+        LOG.debug("--- Print Consumer ---");
+        Consumer<String> printConsumer = new Consumer<String>() {
+            public void accept(String name) {
+                System.out.println(name);
+            };
+        };
+
+        names.forEach(printConsumer);
+
+        // Anonymous inner class that implements Consumer interface
+        LOG.debug("--- Anonymous inner class ---");
+        names.forEach(new Consumer<String>() {
+            public void accept(String name) {
+                LOG.debug(name);
+            }
+        });
+
+        // Java 8 - forEach - Lambda Syntax
+        LOG.debug("--- forEach method ---");
+        names.forEach(name -> LOG.debug(name));
+
+        // Java 8 - forEach - Print elements using a Method Reference
+        LOG.debug("--- Method Reference ---");
+        names.forEach(LOG::debug);
+    }
+
+    @Test
+    public void givenList_thenIterateAndPrintResults() {
+        List<String> names = Arrays.asList("Larry", "Steve", "James");
+
+        names.forEach(System.out::println);
+    }
+
+    @Test
+    public void givenSet_thenIterateAndPrintResults() {
+        Set<String> uniqueNames = new HashSet<>(Arrays.asList("Larry", "Steve", "James"));
+
+        uniqueNames.forEach(System.out::println);
+    }
+
+    @Test
+    public void givenQueue_thenIterateAndPrintResults() {
+        Queue<String> namesQueue = new ArrayDeque<>(Arrays.asList("Larry", "Steve", "James"));
+
+        namesQueue.forEach(System.out::println);
+    }
+
+    @Test
+    public void givenMap_thenIterateAndPrintResults() {
+        Map<Integer, String> namesMap = new HashMap<>();
+        namesMap.put(1, "Larry");
+        namesMap.put(2, "Steve");
+        namesMap.put(3, "James");
+
+        namesMap.entrySet()
+            .forEach(entry -> System.out.println(entry.getKey() + " " + entry.getValue()));
+    }
+
+    @Test
+    public void givenMap_whenUsingBiConsumer_thenIterateAndPrintResults2() {
+        Map<Integer, String> namesMap = new HashMap<>();
+        namesMap.put(1, "Larry");
+        namesMap.put(2, "Steve");
+        namesMap.put(3, "James");
+
+        namesMap.forEach((key, value) -> System.out.println(key + " " + value));
+    }
+
+}
@@ -0,0 +1,67 @@
+package com.baeldung.java8;
+
+import com.baeldung.java_8_features.User;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class Java8MethodReferenceUnitTest {
+
+    private List<String> list;
+
+    @Before
+    public void init() {
+        list = new ArrayList<>();
+        list.add("One");
+        list.add("OneAndOnly");
+        list.add("Derek");
+        list.add("Change");
+        list.add("factory");
+        list.add("justBefore");
+        list.add("Italy");
+        list.add("Italy");
+        list.add("Thursday");
+        list.add("");
+        list.add("");
+    }
+
+    @Test
+    public void checkStaticMethodReferences_whenWork_thenCorrect() {
+
+        List<User> users = new ArrayList<>();
+        users.add(new User());
+        users.add(new User());
+        boolean isReal = users.stream().anyMatch(u -> User.isRealUser(u));
+        boolean isRealRef = users.stream().anyMatch(User::isRealUser);
+        assertTrue(isReal);
+        assertTrue(isRealRef);
+    }
+
+    @Test
+    public void checkInstanceMethodReferences_whenWork_thenCorrect() {
+        User user = new User();
+        boolean isLegalName = list.stream().anyMatch(user::isLegalName);
+        assertTrue(isLegalName);
+    }
+
+    @Test
+    public void checkParticularTypeReferences_whenWork_thenCorrect() {
+        long count = list.stream().filter(String::isEmpty).count();
+        assertEquals(count, 2);
+    }
+
+    @Test
+    public void checkConstructorReferences_whenWork_thenCorrect() {
+        Stream<User> stream = list.stream().map(User::new);
+        List<User> userList = stream.collect(Collectors.toList());
+        assertEquals(userList.size(), list.size());
+        assertTrue(userList.get(0) instanceof User);
+    }
+}
@@ -0,0 +1,116 @@
+package com.baeldung.java8;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.java_8_features.Address;
+import com.baeldung.java_8_features.CustomException;
+import com.baeldung.java_8_features.OptionalAddress;
+import com.baeldung.java_8_features.OptionalUser;
+import com.baeldung.java_8_features.User;
+
+public class Java8OptionalUnitTest {
+
+    private List<String> list;
+
+    @Before
+    public void init() {
+        list = new ArrayList<>();
+        list.add("One");
+        list.add("OneAndOnly");
+        list.add("Derek");
+        list.add("Change");
+        list.add("factory");
+        list.add("justBefore");
+        list.add("Italy");
+        list.add("Italy");
+        list.add("Thursday");
+        list.add("");
+        list.add("");
+    }
+
+    @Test
+    public void checkOptional_whenAsExpected_thenCorrect() {
+        Optional<String> optionalEmpty = Optional.empty();
+        assertFalse(optionalEmpty.isPresent());
+
+        String str = "value";
+        Optional<String> optional = Optional.of(str);
+        assertEquals(optional.get(), "value");
+
+        Optional<String> optionalNullable = Optional.ofNullable(str);
+        Optional<String> optionalNull = Optional.ofNullable(null);
+        assertEquals(optionalNullable.get(), "value");
+        assertFalse(optionalNull.isPresent());
+
+        List<String> listOpt = Optional.of(list).orElse(new ArrayList<>());
+        List<String> listNull = null;
+        List<String> listOptNull = Optional.ofNullable(listNull).orElse(new ArrayList<>());
+        assertTrue(listOpt == list);
+        assertTrue(listOptNull.isEmpty());
+
+        Optional<User> user = Optional.ofNullable(getUser());
+        String result = user.map(User::getAddress).map(Address::getStreet).orElse("not specified");
+        assertEquals(result, "1st Avenue");
+
+        Optional<OptionalUser> optionalUser = Optional.ofNullable(getOptionalUser());
+        String resultOpt = optionalUser.flatMap(OptionalUser::getAddress).flatMap(OptionalAddress::getStreet).orElse("not specified");
+        assertEquals(resultOpt, "1st Avenue");
+
+        Optional<User> userNull = Optional.ofNullable(getUserNull());
+        String resultNull = userNull.map(User::getAddress).map(Address::getStreet).orElse("not specified");
+        assertEquals(resultNull, "not specified");
+
+        Optional<OptionalUser> optionalUserNull = Optional.ofNullable(getOptionalUserNull());
+        String resultOptNull = optionalUserNull.flatMap(OptionalUser::getAddress).flatMap(OptionalAddress::getStreet).orElse("not specified");
+        assertEquals(resultOptNull, "not specified");
+
+    }
+
+    @Test(expected = CustomException.class)
+    public void callMethod_whenCustomException_thenCorrect() {
+        User user = new User();
+        String result = user.getOrThrow();
+    }
+
+    private User getUser() {
+        User user = new User();
+        Address address = new Address();
+        address.setStreet("1st Avenue");
+        user.setAddress(address);
+        return user;
+    }
+
+    private OptionalUser getOptionalUser() {
+        OptionalUser user = new OptionalUser();
+        OptionalAddress address = new OptionalAddress();
+        address.setStreet("1st Avenue");
+        user.setAddress(address);
+        return user;
+    }
+
+    private OptionalUser getOptionalUserNull() {
+        OptionalUser user = new OptionalUser();
+        OptionalAddress address = new OptionalAddress();
+        address.setStreet(null);
+        user.setAddress(address);
+        return user;
+    }
+
+    private User getUserNull() {
+        User user = new User();
+        Address address = new Address();
+        address.setStreet(null);
+        user.setAddress(address);
+        return user;
+    }
+
+}
@@ -0,0 +1,22 @@
+package com.baeldung.java8.comparator;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+@Data
+@AllArgsConstructor
+@ToString
+@EqualsAndHashCode
+public class Employee implements Comparable<Employee>{
+    String name;
+    int age;
+    double salary;
+    long mobile;
+    
+    @Override
+    public int compareTo(Employee argEmployee) {
+        return name.compareTo(argEmployee.getName());
+    }
+    
+}
@@ -0,0 +1,152 @@
+package com.baeldung.java8.comparator;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class Java8ComparatorUnitTest {
+
+    private Employee[] employees;
+    private Employee[] employeesArrayWithNulls;
+    private Employee[] sortedEmployeesByName;
+    private Employee[] sortedEmployeesByNameDesc;
+    private Employee[] sortedEmployeesByAge;
+    private Employee[] sortedEmployeesByMobile;
+    private Employee[] sortedEmployeesBySalary;
+    private Employee[] sortedEmployeesArray_WithNullsFirst;
+    private Employee[] sortedEmployeesArray_WithNullsLast;
+    private Employee[] sortedEmployeesByNameAge;
+    private Employee[] someMoreEmployees;
+    private Employee[] sortedEmployeesByAgeName;;
+
+    @Before
+    public void initData() {
+        employees = new Employee[] { new Employee("John", 25, 3000, 9922001), new Employee("Ace", 22, 2000, 5924001), new Employee("Keith", 35, 4000, 3924401) };
+        employeesArrayWithNulls = new Employee[] { new Employee("John", 25, 3000, 9922001), null, new Employee("Ace", 22, 2000, 5924001), null, new Employee("Keith", 35, 4000, 3924401) };
+
+        sortedEmployeesByName = new Employee[] { new Employee("Ace", 22, 2000, 5924001), new Employee("John", 25, 3000, 9922001), new Employee("Keith", 35, 4000, 3924401) };
+        sortedEmployeesByNameDesc = new Employee[] { new Employee("Keith", 35, 4000, 3924401), new Employee("John", 25, 3000, 9922001), new Employee("Ace", 22, 2000, 5924001) };
+
+        sortedEmployeesByAge = new Employee[] { new Employee("Ace", 22, 2000, 5924001), new Employee("John", 25, 3000, 9922001), new Employee("Keith", 35, 4000, 3924401) };
+
+        sortedEmployeesByMobile = new Employee[] { new Employee("Keith", 35, 4000, 3924401), new Employee("Ace", 22, 2000, 5924001), new Employee("John", 25, 3000, 9922001), };
+
+        sortedEmployeesBySalary = new Employee[] { new Employee("Ace", 22, 2000, 5924001), new Employee("John", 25, 3000, 9922001), new Employee("Keith", 35, 4000, 3924401), };
+
+        sortedEmployeesArray_WithNullsFirst = new Employee[] { null, null, new Employee("Ace", 22, 2000, 5924001), new Employee("John", 25, 3000, 9922001), new Employee("Keith", 35, 4000, 3924401) };
+        sortedEmployeesArray_WithNullsLast = new Employee[] { new Employee("Ace", 22, 2000, 5924001), new Employee("John", 25, 3000, 9922001), new Employee("Keith", 35, 4000, 3924401), null, null };
+
+        someMoreEmployees = new Employee[] { new Employee("Jake", 25, 3000, 9922001), new Employee("Jake", 22, 2000, 5924001), new Employee("Ace", 22, 3000, 6423001), new Employee("Keith", 35, 4000, 3924401) };
+
+        sortedEmployeesByAgeName = new Employee[] { new Employee("Ace", 22, 3000, 6423001), new Employee("Jake", 22, 2000, 5924001), new Employee("Jake", 25, 3000, 9922001), new Employee("Keith", 35, 4000, 3924401) };
+        sortedEmployeesByNameAge = new Employee[] { new Employee("Ace", 22, 3000, 6423001), new Employee("Jake", 22, 2000, 5924001), new Employee("Jake", 25, 3000, 9922001), new Employee("Keith", 35, 4000, 3924401) };
+    }
+
+    @Test
+    public void whenComparing_thenSortedByName() {
+        Comparator<Employee> employeeNameComparator = Comparator.comparing(Employee::getName);
+        Arrays.sort(employees, employeeNameComparator);
+        // System.out.println(Arrays.toString(employees));
+        assertTrue(Arrays.equals(employees, sortedEmployeesByName));
+    }
+
+    @Test
+    public void whenComparingWithComparator_thenSortedByNameDesc() {
+        Comparator<Employee> employeeNameComparator = Comparator.comparing(Employee::getName, (s1, s2) -> {
+            return s2.compareTo(s1);
+        });
+        Arrays.sort(employees, employeeNameComparator);
+        // System.out.println(Arrays.toString(employees));
+        assertTrue(Arrays.equals(employees, sortedEmployeesByNameDesc));
+    }
+
+    @Test
+    public void whenReversed_thenSortedByNameDesc() {
+        Comparator<Employee> employeeNameComparator = Comparator.comparing(Employee::getName);
+        Comparator<Employee> employeeNameComparatorReversed = employeeNameComparator.reversed();
+        Arrays.sort(employees, employeeNameComparatorReversed);
+        // System.out.println(Arrays.toString(employees));
+        assertTrue(Arrays.equals(employees, sortedEmployeesByNameDesc));
+    }
+
+    @Test
+    public void whenComparingInt_thenSortedByAge() {
+        Comparator<Employee> employeeAgeComparator = Comparator.comparingInt(Employee::getAge);
+        Arrays.sort(employees, employeeAgeComparator);
+        // System.out.println(Arrays.toString(employees));
+        assertTrue(Arrays.equals(employees, sortedEmployeesByAge));
+    }
+
+    @Test
+    public void whenComparingLong_thenSortedByMobile() {
+        Comparator<Employee> employeeMobileComparator = Comparator.comparingLong(Employee::getMobile);
+        Arrays.sort(employees, employeeMobileComparator);
+        // System.out.println(Arrays.toString(employees));
+        assertTrue(Arrays.equals(employees, sortedEmployeesByMobile));
+    }
+
+    @Test
+    public void whenComparingDouble_thenSortedBySalary() {
+        Comparator<Employee> employeeSalaryComparator = Comparator.comparingDouble(Employee::getSalary);
+        Arrays.sort(employees, employeeSalaryComparator);
+        // System.out.println(Arrays.toString(employees));
+        assertTrue(Arrays.equals(employees, sortedEmployeesBySalary));
+    }
+
+    @Test
+    public void whenNaturalOrder_thenSortedByName() {
+        Comparator<Employee> employeeNameComparator = Comparator.<Employee> naturalOrder();
+        Arrays.sort(employees, employeeNameComparator);
+        // System.out.println(Arrays.toString(employees));
+        assertTrue(Arrays.equals(employees, sortedEmployeesByName));
+    }
+
+    @Test
+    public void whenReverseOrder_thenSortedByNameDesc() {
+        Comparator<Employee> employeeNameComparator = Comparator.<Employee> reverseOrder();
+        Arrays.sort(employees, employeeNameComparator);
+        // System.out.println(Arrays.toString(employees));
+        assertTrue(Arrays.equals(employees, sortedEmployeesByNameDesc));
+    }
+
+    @Test
+    public void whenNullsFirst_thenSortedByNameWithNullsFirst() {
+        Comparator<Employee> employeeNameComparator = Comparator.comparing(Employee::getName);
+        Comparator<Employee> employeeNameComparator_nullFirst = Comparator.nullsFirst(employeeNameComparator);
+        Arrays.sort(employeesArrayWithNulls, employeeNameComparator_nullFirst);
+        // System.out.println(Arrays.toString(employeesArrayWithNulls));
+        assertTrue(Arrays.equals(employeesArrayWithNulls, sortedEmployeesArray_WithNullsFirst));
+    }
+
+    @Test
+    public void whenNullsLast_thenSortedByNameWithNullsLast() {
+        Comparator<Employee> employeeNameComparator = Comparator.comparing(Employee::getName);
+        Comparator<Employee> employeeNameComparator_nullLast = Comparator.nullsLast(employeeNameComparator);
+        Arrays.sort(employeesArrayWithNulls, employeeNameComparator_nullLast);
+        // System.out.println(Arrays.toString(employeesArrayWithNulls));
+        assertTrue(Arrays.equals(employeesArrayWithNulls, sortedEmployeesArray_WithNullsLast));
+    }
+
+    @Test
+    public void whenThenComparing_thenSortedByAgeName() {
+        Comparator<Employee> employee_Age_Name_Comparator = Comparator.comparing(Employee::getAge).thenComparing(Employee::getName);
+
+        Arrays.sort(someMoreEmployees, employee_Age_Name_Comparator);
+        // System.out.println(Arrays.toString(someMoreEmployees));
+        assertTrue(Arrays.equals(someMoreEmployees, sortedEmployeesByAgeName));
+    }
+
+    @Test
+    public void whenThenComparing_thenSortedByNameAge() {
+        Comparator<Employee> employee_Name_Age_Comparator = Comparator.comparing(Employee::getName).thenComparingInt(Employee::getAge);
+
+        Arrays.sort(someMoreEmployees, employee_Name_Age_Comparator);
+        // System.out.println(Arrays.toString(someMoreEmployees));
+        assertTrue(Arrays.equals(someMoreEmployees, sortedEmployeesByNameAge));
+    }
+
+}
@@ -0,0 +1,39 @@
+package com.baeldung.monad;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MonadSampleUnitTest {
+
+    @Test
+    public void whenNotUsingMonad_shouldBeOk() {
+        MonadSample1 test = new MonadSample1();
+        Assert.assertEquals(6.0, test.apply(2), 0.000);
+    }
+
+    @Test
+    public void whenNotUsingMonadButUsingTempVars_shouldBeOk() {
+        MonadSample2 test = new MonadSample2();
+        Assert.assertEquals(6.0, test.apply(2), 0.000);
+    }
+
+    @Test
+    public void whenUsingMonad_shouldBeOk() {
+        MonadSample3 test = new MonadSample3();
+        Assert.assertEquals(6.0, test.apply(2), 0.000);
+    }
+
+    @Test
+    public void whenTestingMonadProperties_shouldBeOk() {
+        MonadSample4 test = new MonadSample4();
+        Assert.assertEquals(true, test.leftIdentity());
+        Assert.assertEquals(true, test.rightIdentity());
+        Assert.assertEquals(true, test.associativity());
+    }
+
+    @Test
+    public void whenBreakingMonadProperties_shouldBeFalse() {
+        MonadSample5 test = new MonadSample5();
+        Assert.assertEquals(false, test.fail());
+    }
+}
@@ -0,0 +1,41 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.stream.Stream;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+
+public class NullSafeCollectionStreamsUsingCommonsEmptyIfNullUnitTest {
+
+    private final NullSafeCollectionStreamsUsingCommonsEmptyIfNull instance = 
+            new NullSafeCollectionStreamsUsingCommonsEmptyIfNull();
+
+    @Test
+    public void whenCollectionIsNull_thenExpectAnEmptyStream() {
+        Collection<String> collection = null;
+        Stream<String> expResult = Stream.empty();
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+
+    }
+
+    @Test
+    public void whenCollectionHasElements_thenExpectAStreamOfExactlyTheSameElements() {
+
+        Collection<String> collection = Arrays.asList("a", "b", "c");
+        Stream<String> expResult = Arrays.stream(new String[] { "a", "b", "c" });
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+    }
+
+    private static void assertStreamEquals(Stream<?> s1, Stream<?> s2) {
+        Iterator<?> iter1 = s1.iterator(), iter2 = s2.iterator();
+        while (iter1.hasNext() && iter2.hasNext())
+            assertEquals(iter1.next(), iter2.next());
+        assert !iter1.hasNext() && !iter2.hasNext();
+    }
+    
+}
@@ -0,0 +1,50 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.baeldung.nullsafecollectionstreams;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.stream.Stream;
+
+import org.junit.Test;
+
+/**
+ *
+ * @author Kwaje Anthony <[email protected]>
+ */
+public class NullSafeCollectionStreamsUsingJava8OptionalContainerUnitTest {
+
+    private final NullSafeCollectionStreamsUsingJava8OptionalContainer instance = new NullSafeCollectionStreamsUsingJava8OptionalContainer();
+
+    @Test
+    public void whenCollectionIsNull_thenExpectAnEmptyStream() {
+        Collection<String> collection = null;
+        Stream<String> expResult = Stream.empty();
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+
+    }
+
+    @Test
+    public void whenCollectionHasElements_thenExpectAStreamOfExactlyTheSameElements() {
+
+        Collection<String> collection = Arrays.asList("a", "b", "c");
+        Stream<String> expResult = Arrays.stream(new String[] { "a", "b", "c" });
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+    }
+
+    private static void assertStreamEquals(Stream<?> s1, Stream<?> s2) {
+        Iterator<?> iter1 = s1.iterator(), iter2 = s2.iterator();
+        while (iter1.hasNext() && iter2.hasNext())
+            assertEquals(iter1.next(), iter2.next());
+        assert !iter1.hasNext() && !iter2.hasNext();
+    }
+
+}
@@ -0,0 +1,45 @@
+
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.stream.Stream;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Kwaje Anthony <[email protected]>
+ */
+public class NullSafeCollectionStreamsUsingNullDereferenceCheckUnitTest {
+
+    private final NullSafeCollectionStreamsUsingNullDereferenceCheck instance = 
+            new NullSafeCollectionStreamsUsingNullDereferenceCheck();
+
+    @Test
+    public void whenCollectionIsNull_thenExpectAnEmptyStream() {
+        Collection<String> collection = null;
+        Stream<String> expResult = Stream.empty();
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+
+    }
+
+    @Test
+    public void whenCollectionHasElements_thenExpectAStreamOfExactlyTheSameElements() {
+
+        Collection<String> collection = Arrays.asList("a", "b", "c");
+        Stream<String> expResult = Arrays.stream(new String[] { "a", "b", "c" });
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+    }
+
+    private static void assertStreamEquals(Stream<?> s1, Stream<?> s2) {
+        Iterator<?> iter1 = s1.iterator(), iter2 = s2.iterator();
+        while (iter1.hasNext() && iter2.hasNext())
+            assertEquals(iter1.next(), iter2.next());
+        assert !iter1.hasNext() && !iter2.hasNext();
+    }
+
+}
--- a/Show More
+++ b/Show More