Merge remote-tracking branch 'upstream/master'

.gitignore

@@ -1,4 +1,5 @@
 */bin/*
+bin/
 
 *.class
 
@@ -21,6 +22,9 @@
 *.iws
 out/
 
+# VSCode
+.vscode/
+
 # Mac
 .DS_Store
 
@@ -77,4 +81,5 @@ apache-avro/src/main/java/com/baeldung/avro/model/
 jta/transaction-logs/
 software-security/sql-injection-samples/derby.log
 spring-soap/src/main/java/com/baeldung/springsoap/gen/
-/report-*.json
+/report-*.json
+transaction.log

README.md

@@ -1,12 +1,16 @@
 
-The "REST with Spring" Classes
+The Courses
 ==============================
 
-Here's the Master Class of REST With Spring (along with the newly announced Boot 2 material): <br/>
-**[>> THE REST WITH SPRING - MASTER CLASS](http://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
 
-And here's the Master Class of Learn Spring Security: <br/>
-**[>> LEARN SPRING SECURITY - MASTER CLASS](http://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**
+Here's the new "Learn Spring" course: <br/>
+**[>> LEARN SPRING - THE MASTER CLASS](https://www.baeldung.com/learn-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=ls#master-class)**
+
+Here's the Master Class of "REST With Spring" (along with the new announced Boot 2 material): <br/>
+**[>> THE REST WITH SPRING - MASTER CLASS](https://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
+
+And here's the Master Class of "Learn Spring Security": <br/>
+**[>> LEARN SPRING SECURITY - MASTER CLASS](https://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**
 
 
 
@@ -15,7 +19,7 @@ Java and Spring Tutorials
 
 This project is **a collection of small and focused tutorials** - each covering a single and well defined area of development in the Java ecosystem. 
 A strong focus of these is, of course, the Spring Framework - Spring, Spring Boot and Spring Security. 
-In additional to Spring, the following technologies are in focus: `core Java`, `Jackson`, `HttpClient`, `Guava`. 
+In additional to Spring, the modules here are covering a number of aspects in Java. 
 
 
 Building the project
@@ -32,8 +36,15 @@ Running a Spring Boot module
 ====================
 To run a Spring Boot module run the command: `mvn spring-boot:run` in the module directory
 
-#Running Tests
 
+Working with the IDE
+====================
+This repo contains a large number of modules. 
+When you're working with an individual module, there's no need to import all of them (or build all of them) - you can simply import that particular module in either Eclipse or IntelliJ. 
+
+
+Running Tests
+=============
 The command `mvn clean install` will run the unit tests in a module.
 To run the integration tests, use the command `mvn clean install -Pintegration-lite-first`
 

algorithms-miscellaneous-1/pom.xml

@@ -42,7 +42,7 @@
         <dependency>
             <groupId>com.github.dpaukov</groupId>
             <artifactId>combinatoricslib3</artifactId>
-            <version>3.3.0</version>
+            <version>${combinatoricslib3.version}</version>
          </dependency>
     </dependencies>
 
@@ -83,6 +83,7 @@
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
         <guava.version>27.0.1-jre</guava.version>
+        <combinatoricslib3.version>3.3.0</combinatoricslib3.version>
     </properties>
 
 </project>

algorithms-miscellaneous-3/README.md

@@ -4,3 +4,6 @@
 - [Implementing Simple State Machines with Java Enums](https://www.baeldung.com/java-enum-simple-state-machine)
 - [Converting Between Roman and Arabic Numerals in Java](http://www.baeldung.com/java-convert-roman-arabic)
 - [Practical Java Examples of the Big O Notation](http://www.baeldung.com/java-algorithm-complexity)
+- [Checking If a List Is Sorted in Java](https://www.baeldung.com/java-check-if-list-sorted)
+- [Checking if a Java Graph has a Cycle](https://www.baeldung.com/java-graph-has-a-cycle)
+- [A Guide to the Folding Technique in Java](https://www.baeldung.com/folding-hashing-technique)

algorithms-miscellaneous-3/pom.xml

@@ -18,6 +18,18 @@
             <version>${org.assertj.core.version}</version>
             <scope>test</scope>
         </dependency>
+        
+        <dependency>
+        	<groupId>org.apache.commons</groupId>
+        	<artifactId>commons-collections4</artifactId>
+        	<version>${commons-collections4.version}</version>
+        </dependency>
+        
+        <dependency>
+        	<groupId>com.google.guava</groupId>
+        	<artifactId>guava</artifactId>
+        	<version>${guava.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -34,6 +46,7 @@
 
     <properties>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
+        <commons-collections4.version>4.3</commons-collections4.version>
+        <guava.version>28.0-jre</guava.version>
     </properties>
-
 </project>

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/checksortedlist/Employee.java

@@ -0,0 +1,34 @@
+package com.baeldung.algorithms.checksortedlist;
+
+public class Employee {
+
+    long id;
+
+    String name;
+
+    public Employee() {
+    }
+
+    public Employee(long id, String name) {
+        super();
+        this.id = id;
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/checksortedlist/SortedListChecker.java

@@ -0,0 +1,87 @@
+package com.baeldung.algorithms.checksortedlist;
+
+import static org.apache.commons.collections4.CollectionUtils.isEmpty;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+
+import com.google.common.collect.Comparators;
+import com.google.common.collect.Ordering;;
+
+public class SortedListChecker {
+
+    private SortedListChecker() {
+        throw new AssertionError();
+    }
+
+    public static boolean checkIfSortedUsingIterativeApproach(List<String> listOfStrings) {
+        if (isEmpty(listOfStrings) || listOfStrings.size() == 1) {
+            return true;
+        }
+
+        Iterator<String> iter = listOfStrings.iterator();
+        String current, previous = iter.next();
+        while (iter.hasNext()) {
+            current = iter.next();
+            if (previous.compareTo(current) > 0) {
+                return false;
+            }
+            previous = current;
+        }
+        return true;
+    }
+
+    public static boolean checkIfSortedUsingIterativeApproach(List<Employee> employees, Comparator<Employee> employeeComparator) {
+        if (isEmpty(employees) || employees.size() == 1) {
+            return true;
+        }
+
+        Iterator<Employee> iter = employees.iterator();
+        Employee current, previous = iter.next();
+        while (iter.hasNext()) {
+            current = iter.next();
+            if (employeeComparator.compare(previous, current) > 0) {
+                return false;
+            }
+            previous = current;
+        }
+        return true;
+    }
+
+    public static boolean checkIfSortedUsingRecursion(List<String> listOfStrings) {
+        return isSortedRecursive(listOfStrings, listOfStrings.size());
+    }
+
+    public static boolean isSortedRecursive(List<String> listOfStrings, int index) {
+        if (index < 2) {
+            return true;
+        } else if (listOfStrings.get(index - 2)
+            .compareTo(listOfStrings.get(index - 1)) > 0) {
+            return false;
+        } else {
+            return isSortedRecursive(listOfStrings, index - 1);
+        }
+    }
+
+    public static boolean checkIfSortedUsingOrderingClass(List<String> listOfStrings) {
+        return Ordering.<String> natural()
+            .isOrdered(listOfStrings);
+    }
+
+    public static boolean checkIfSortedUsingOrderingClass(List<Employee> employees, Comparator<Employee> employeeComparator) {
+        return Ordering.from(employeeComparator)
+            .isOrdered(employees);
+    }
+
+    public static boolean checkIfSortedUsingOrderingClassHandlingNull(List<String> listOfStrings) {
+        return Ordering.<String> natural()
+            .nullsLast()
+            .isOrdered(listOfStrings);
+    }
+
+    public static boolean checkIfSortedUsingComparators(List<String> listOfStrings) {
+        return Comparators.isInOrder(listOfStrings, Comparator.<String> naturalOrder());
+    }
+
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/graphcycledetection/domain/Graph.java

@@ -0,0 +1,51 @@
+package com.baeldung.algorithms.graphcycledetection.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Graph {
+
+    private List<Vertex> vertices;
+
+    public Graph() {
+        this.vertices = new ArrayList<>();
+    }
+
+    public Graph(List<Vertex> vertices) {
+        this.vertices = vertices;
+    }
+
+    public void addVertex(Vertex vertex) {
+        this.vertices.add(vertex);
+    }
+
+    public void addEdge(Vertex from, Vertex to) {
+        from.addNeighbour(to);
+    }
+
+    public boolean hasCycle() {
+        for (Vertex vertex : vertices) {
+            if (!vertex.isVisited() && hasCycle(vertex)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean hasCycle(Vertex sourceVertex) {
+        sourceVertex.setBeingVisited(true);
+
+        for (Vertex neighbour : sourceVertex.getAdjacencyList()) {
+            if (neighbour.isBeingVisited()) {
+                // backward edge exists
+                return true;
+            } else if (!neighbour.isVisited() && hasCycle(neighbour)) {
+                return true;
+            }
+        }
+
+        sourceVertex.setBeingVisited(false);
+        sourceVertex.setVisited(true);
+        return false;
+    }
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/graphcycledetection/domain/Vertex.java

@@ -0,0 +1,56 @@
+package com.baeldung.algorithms.graphcycledetection.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Vertex {
+
+    private String label;
+
+    private boolean visited;
+
+    private boolean beingVisited;
+
+    private List<Vertex> adjacencyList;
+
+    public Vertex(String label) {
+        this.label = label;
+        this.adjacencyList = new ArrayList<>();
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public boolean isVisited() {
+        return visited;
+    }
+
+    public void setVisited(boolean visited) {
+        this.visited = visited;
+    }
+
+    public boolean isBeingVisited() {
+        return beingVisited;
+    }
+
+    public void setBeingVisited(boolean beingVisited) {
+        this.beingVisited = beingVisited;
+    }
+
+    public List<Vertex> getAdjacencyList() {
+        return adjacencyList;
+    }
+
+    public void setAdjacencyList(List<Vertex> adjacencyList) {
+        this.adjacencyList = adjacencyList;
+    }
+
+    public void addNeighbour(Vertex adjacent) {
+        this.adjacencyList.add(adjacent);
+    }
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/stringsortingbynumber/NaturalOrderComparators.java

@@ -0,0 +1,30 @@
+package com.baeldung.algorithms.stringsortingbynumber;
+
+import java.util.Comparator;
+
+public final class NaturalOrderComparators {
+
+    private static final String DIGIT_AND_DECIMAL_REGEX = "[^\\d.]";
+
+    private NaturalOrderComparators() {
+        throw new AssertionError("Let's keep this static");
+    }
+
+    public static Comparator<String> createNaturalOrderRegexComparator() {
+        return Comparator.comparingDouble(NaturalOrderComparators::parseStringToNumber);
+    }
+
+    private static double parseStringToNumber(String input){
+
+        final String digitsOnly = input.replaceAll(DIGIT_AND_DECIMAL_REGEX, "");
+
+        if("".equals(digitsOnly)) return 0;
+
+        try{
+            return Double.parseDouble(digitsOnly);
+        }catch (NumberFormatException nfe){
+            return 0;
+        }
+    }
+
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/folding/FoldingHash.java

@@ -0,0 +1,78 @@
+package com.baeldung.folding;
+
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+/**
+ * Calculate a hash value for the strings using the folding technique.
+ * 
+ * The implementation serves only to the illustration purposes and is far
+ * from being the most efficient. 
+ * 
+ * @author A.Shcherbakov
+ *
+ */
+public class FoldingHash {
+
+    /**
+     * Calculate the hash value of a given string.
+     * 
+     * @param str Assume it is not null
+     * @param groupSize the group size in the folding technique
+     * @param maxValue defines a max value that the hash may acquire (exclusive)     
+     * @return integer value from 0 (inclusive) to maxValue (exclusive)
+     */
+    public int hash(String str, int groupSize, int maxValue) {
+        final int[] codes = this.toAsciiCodes(str);
+        return IntStream.range(0, str.length())
+            .filter(i -> i % groupSize == 0)
+            .mapToObj(i -> extract(codes, i, groupSize))
+            .map(block -> concatenate(block))
+            .reduce(0, (a, b) -> (a + b) % maxValue);
+    }
+
+    /**
+     * Returns a new array of given length whose elements are take from 
+     * the original one starting from the offset.
+     *  
+     * If the original array has not enough elements, the returning array will contain 
+     * element from the offset till the end of the original array.
+     *  
+     * @param numbers original array. Assume it is not null.
+     * @param offset index of the element to start from. Assume it is less than the size of the array 
+     * @param length max size of the resulting array
+     * @return
+     */
+    public int[] extract(int[] numbers, int offset, int length) {
+        final int defect = numbers.length - (offset + length);
+        final int s = defect < 0 ? length + defect : length;
+        int[] result = new int[s];
+        for (int index = 0; index < s; index++) {
+            result[index] = numbers[index + offset];
+        }
+        return result;
+    }
+
+    /**
+     * Concatenate the numbers into a single number as if they were strings.
+     * Assume that the procedure does not suffer from the overflow.
+     * @param numbers integers to concatenate
+     * @return
+     */
+    public int concatenate(int[] numbers) {
+        final String merged = IntStream.of(numbers)
+            .mapToObj(number -> "" + number)
+            .collect(Collectors.joining());
+        return Integer.parseInt(merged, 10);
+    }
+
+    /**
+     * Convert the string into its characters' ASCII codes.
+     * @param str input string
+     * @return
+     */
+    private int[] toAsciiCodes(String str) {
+        return str.chars()
+            .toArray();
+    }
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/folding/Main.java

@@ -0,0 +1,17 @@
+package com.baeldung.folding;
+
+/**
+ * Code snippet for article "A Guide to the Folding Technique".
+ *  
+ * @author A.Shcherbakov
+ *
+ */
+public class Main {
+
+    public static void main(String... arg) {
+        FoldingHash hasher = new FoldingHash();
+        final String str = "Java language";
+        System.out.println(hasher.hash(str, 2, 100_000));
+        System.out.println(hasher.hash(str, 3, 1_000));
+    }
+}

algorithms-miscellaneous-3/src/test/java/com/baeldung/algorithms/checksortedlist/SortedListCheckerUnitTest.java

@@ -0,0 +1,106 @@
+package com.baeldung.algorithms.checksortedlist;
+
+import static com.baeldung.algorithms.checksortedlist.SortedListChecker.checkIfSortedUsingComparators;
+import static com.baeldung.algorithms.checksortedlist.SortedListChecker.checkIfSortedUsingIterativeApproach;
+import static com.baeldung.algorithms.checksortedlist.SortedListChecker.checkIfSortedUsingOrderingClass;
+import static com.baeldung.algorithms.checksortedlist.SortedListChecker.checkIfSortedUsingRecursion;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class SortedListCheckerUnitTest {
+
+    private List<String> sortedListOfString;
+    private List<String> unsortedListOfString;
+    private List<String> singletonList;
+
+    private List<Employee> employeesSortedByName;
+    private List<Employee> employeesNotSortedByName;
+
+    @Before
+    public void setUp() {
+        sortedListOfString = asList("Canada", "HK", "LA", "NJ", "NY");
+        unsortedListOfString = asList("LA", "HK", "NJ", "NY", "Canada");
+        singletonList = Collections.singletonList("NY");
+
+        employeesSortedByName = asList(new Employee(1L, "John"), new Employee(2L, "Kevin"), new Employee(3L, "Mike"));
+        employeesNotSortedByName = asList(new Employee(1L, "Kevin"), new Employee(2L, "John"), new Employee(3L, "Mike"));
+    }
+
+    @Test
+    public void givenSortedList_whenUsingIterativeApproach_thenReturnTrue() {
+        assertThat(checkIfSortedUsingIterativeApproach(sortedListOfString)).isTrue();
+    }
+
+    @Test
+    public void givenSingleElementList_whenUsingIterativeApproach_thenReturnTrue() {
+        assertThat(checkIfSortedUsingIterativeApproach(singletonList)).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedList_whenUsingIterativeApproach_thenReturnFalse() {
+        assertThat(checkIfSortedUsingIterativeApproach(unsortedListOfString)).isFalse();
+    }
+
+    @Test
+    public void givenSortedListOfEmployees_whenUsingIterativeApproach_thenReturnTrue() {
+        assertThat(checkIfSortedUsingIterativeApproach(employeesSortedByName, Comparator.comparing(Employee::getName))).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedListOfEmployees_whenUsingIterativeApproach_thenReturnFalse() {
+        assertThat(checkIfSortedUsingIterativeApproach(employeesNotSortedByName, Comparator.comparing(Employee::getName))).isFalse();
+    }
+
+    @Test
+    public void givenSortedList_whenUsingRecursion_thenReturnTrue() {
+        assertThat(checkIfSortedUsingRecursion(sortedListOfString)).isTrue();
+    }
+
+    @Test
+    public void givenSingleElementList_whenUsingRecursion_thenReturnTrue() {
+        assertThat(checkIfSortedUsingRecursion(singletonList)).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedList_whenUsingRecursion_thenReturnFalse() {
+        assertThat(checkIfSortedUsingRecursion(unsortedListOfString)).isFalse();
+    }
+
+    @Test
+    public void givenSortedList_whenUsingGuavaOrdering_thenReturnTrue() {
+        assertThat(checkIfSortedUsingOrderingClass(sortedListOfString)).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedList_whenUsingGuavaOrdering_thenReturnFalse() {
+        assertThat(checkIfSortedUsingOrderingClass(unsortedListOfString)).isFalse();
+    }
+
+    @Test
+    public void givenSortedListOfEmployees_whenUsingGuavaOrdering_thenReturnTrue() {
+        assertThat(checkIfSortedUsingOrderingClass(employeesSortedByName, Comparator.comparing(Employee::getName))).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedListOfEmployees_whenUsingGuavaOrdering_thenReturnFalse() {
+        assertThat(checkIfSortedUsingOrderingClass(employeesNotSortedByName, Comparator.comparing(Employee::getName))).isFalse();
+    }
+
+    @Test
+    public void givenSortedList_whenUsingGuavaComparators_thenReturnTrue() {
+        assertThat(checkIfSortedUsingComparators(sortedListOfString)).isTrue();
+    }
+
+    @Test
+    public void givenUnsortedList_whenUsingGuavaComparators_thenReturnFalse() {
+        assertThat(checkIfSortedUsingComparators(unsortedListOfString)).isFalse();
+    }
+
+}

algorithms-miscellaneous-3/src/test/java/com/baeldung/algorithms/graphcycledetection/GraphCycleDetectionUnitTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.algorithms.graphcycledetection;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import com.baeldung.algorithms.graphcycledetection.domain.Graph;
+import com.baeldung.algorithms.graphcycledetection.domain.Vertex;
+
+public class GraphCycleDetectionUnitTest {
+
+    @Test
+    public void givenGraph_whenCycleExists_thenReturnTrue() {
+
+        Vertex vertexA = new Vertex("A");
+        Vertex vertexB = new Vertex("B");
+        Vertex vertexC = new Vertex("C");
+        Vertex vertexD = new Vertex("D");
+
+        Graph graph = new Graph();
+        graph.addVertex(vertexA);
+        graph.addVertex(vertexB);
+        graph.addVertex(vertexC);
+        graph.addVertex(vertexD);
+
+        graph.addEdge(vertexA, vertexB);
+        graph.addEdge(vertexB, vertexC);
+        graph.addEdge(vertexC, vertexA);
+        graph.addEdge(vertexD, vertexC);
+
+        assertTrue(graph.hasCycle());
+    }
+
+    @Test
+    public void givenGraph_whenNoCycleExists_thenReturnFalse() {
+
+        Vertex vertexA = new Vertex("A");
+        Vertex vertexB = new Vertex("B");
+        Vertex vertexC = new Vertex("C");
+        Vertex vertexD = new Vertex("D");
+
+        Graph graph = new Graph();
+        graph.addVertex(vertexA);
+        graph.addVertex(vertexB);
+        graph.addVertex(vertexC);
+        graph.addVertex(vertexD);
+
+        graph.addEdge(vertexA, vertexB);
+        graph.addEdge(vertexB, vertexC);
+        graph.addEdge(vertexA, vertexC);
+        graph.addEdge(vertexD, vertexC);
+
+        assertFalse(graph.hasCycle());
+    }
+}

algorithms-miscellaneous-3/src/test/java/com/baeldung/algorithms/stringsortingbynumber/NaturalOrderComparatorsUnitTest.java

@@ -0,0 +1,79 @@
+package com.baeldung.algorithms.stringsortingbynumber;
+
+import com.baeldung.algorithms.stringsortingbynumber.NaturalOrderComparators;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class NaturalOrderComparatorsUnitTest {
+
+    @Test
+    public void givenSimpleStringsContainingIntsAndDoubles_whenSortedByRegex_checkSortingCorrect() {
+
+        List<String> testStrings = Arrays.asList("a1", "b3", "c4", "d2.2", "d2.4", "d2.3d");
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        List<String> expected = Arrays.asList("a1", "d2.2", "d2.3d", "d2.4", "b3", "c4");
+
+        assertEquals(expected, testStrings);
+
+
+    }
+
+    @Test
+    public void givenSimpleStringsContainingIntsAndDoublesWithAnInvalidNumber_whenSortedByRegex_checkSortingCorrect() {
+
+        List<String> testStrings = Arrays.asList("a1", "b3", "c4", "d2.2", "d2.4", "d2.3.3d");
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        List<String> expected = Arrays.asList("d2.3.3d", "a1", "d2.2", "d2.4", "b3", "c4");
+
+        assertEquals(expected, testStrings);
+
+
+    }
+
+    @Test
+    public void givenAllForseenProblems_whenSortedByRegex_checkSortingCorrect() {
+
+        List<String> testStrings = Arrays.asList("a1", "b3", "c4", "d2.2", "d2.f4", "d2.3.3d");
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        List<String> expected = Arrays.asList("d2.3.3d", "a1", "d2.2", "d2.f4", "b3", "c4");
+
+        assertEquals(expected, testStrings);
+
+
+    }
+
+    @Test
+    public void givenComplexStringsContainingSeparatedNumbers_whenSortedByRegex_checkNumbersCondensedAndSorted() {
+
+        List<String> testStrings = Arrays.asList("a1b2c5", "b3ght3.2", "something65.thensomething5"); //125, 33.2, 65.5
+
+        List<String> expected = Arrays.asList("b3ght3.2", "something65.thensomething5", "a1b2c5" );
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        assertEquals(expected, testStrings);
+
+    }
+
+    @Test
+    public void givenStringsNotContainingNumbers_whenSortedByRegex_checkOrderNotChanged() {
+
+        List<String> testStrings = Arrays.asList("a", "c", "d", "e");
+        List<String> expected = new ArrayList<>(testStrings);
+
+        testStrings.sort(NaturalOrderComparators.createNaturalOrderRegexComparator());
+
+        assertEquals(expected, testStrings);
+    }
+}

algorithms-miscellaneous-3/src/test/java/com/baeldung/folding/FoldingHashUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.folding;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class FoldingHashUnitTest {
+
+    @Test
+    public void givenStringJavaLanguage_whenSize2Capacity100000_then48933() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int value = hasher.hash("Java language", 2, 100_000);
+        assertEquals(value, 48933);
+    }
+
+    @Test
+    public void givenStringVaJaLanguage_whenSize2Capacity100000_thenSameAsJavaLanguage() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int java = hasher.hash("Java language", 2, 100_000);
+        final int vaja = hasher.hash("vaJa language", 2, 100_000);
+        assertTrue(java == vaja);
+    }
+
+    @Test
+    public void givenSingleElementArray_whenOffset0Size2_thenSingleElement() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int[] value = hasher.extract(new int[] { 5 }, 0, 2);
+        assertArrayEquals(new int[] { 5 }, value);
+    }
+
+    @Test
+    public void givenFiveElementArray_whenOffset0Size3_thenFirstThreeElements() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int[] value = hasher.extract(new int[] { 1, 2, 3, 4, 5 }, 0, 3);
+        assertArrayEquals(new int[] { 1, 2, 3 }, value);
+    }
+
+    @Test
+    public void givenFiveElementArray_whenOffset1Size2_thenTwoElements() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int[] value = hasher.extract(new int[] { 1, 2, 3, 4, 5 }, 1, 2);
+        assertArrayEquals(new int[] { 2, 3 }, value);
+    }
+
+    @Test
+    public void givenFiveElementArray_whenOffset2SizeTooBig_thenElementsToTheEnd() throws Exception {
+        final FoldingHash hasher = new FoldingHash();
+        final int[] value = hasher.extract(new int[] { 1, 2, 3, 4, 5 }, 2, 2000);
+        assertArrayEquals(new int[] { 3, 4, 5 }, value);
+    }
+
+}

algorithms-sorting/src/main/java/com/baeldung/algorithms/shellsort/ShellSort.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.shellsort;
+
+public class ShellSort {
+
+    public static void sort(int arrayToSort[]) {
+        int n = arrayToSort.length;
+
+        for (int gap = n / 2; gap > 0; gap /= 2) {
+            for (int i = gap; i < n; i++) {
+                int key = arrayToSort[i];
+                int j = i;
+                while (j >= gap && arrayToSort[j - gap] > key) {
+                    arrayToSort[j] = arrayToSort[j - gap];
+                    j -= gap;
+                }
+                arrayToSort[j] = key;
+            }
+        }
+    }
+}

algorithms-sorting/src/test/java/com/baeldung/algorithms/shellsort/ShellSortUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.algorithms.shellsort;
+
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertArrayEquals;
+
+import org.junit.Test;
+
+public class ShellSortUnitTest {
+
+    @Test
+    public void givenUnsortedArray_whenShellSort_thenSortedAsc() {
+        int[] input = {41, 15, 82, 5, 65, 19, 32, 43, 8};
+        ShellSort.sort(input);
+        int[] expected = {5, 8, 15, 19, 32, 41, 43, 65, 82};
+        assertArrayEquals("the two arrays are not equal", expected, input);
+    }
+}

apache-avro/pom.xml

@@ -17,7 +17,7 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.10</version>
+            <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>

apache-olingo/olingo2/pom.xml

@@ -3,37 +3,28 @@
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
-	<parent>
-		<groupId>org.springframework.boot</groupId>
-		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>2.1.3.RELEASE</version>
-		<relativePath /> <!-- lookup parent from repository -->
-	</parent>
 	<groupId>org.baeldung.examples.olingo2</groupId>
 	<artifactId>olingo2-sample</artifactId>
 	<version>0.0.1-SNAPSHOT</version>
 	<name>olingo2-sample</name>
 	<description>Sample Olingo 2 Project</description>
 
-	<properties>
-		<java.version>1.8</java.version>
-		<olingo2.version>2.0.11</olingo2.version>
-	</properties>
+    <parent>
+        <artifactId>parent-boot-2</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-boot-2</relativePath>
+    </parent>
 
 	<dependencies>
-
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-jersey</artifactId>
 		</dependency>
-
-
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-data-jpa</artifactId>
 		</dependency>
-
-
 		<dependency>
 			<groupId>com.h2database</groupId>
 			<artifactId>h2</artifactId>
@@ -90,4 +81,8 @@
 		</plugins>
 	</build>
 
+	<properties>
+		<olingo2.version>2.0.11</olingo2.version>
+	</properties>
+
 </project>

apache-olingo/olingo2/src/test/java/org/baeldung/examples/olingo2/Olingo2SampleApplicationUnitTest.java

@@ -7,7 +7,7 @@ import org.springframework.test.context.junit4.SpringRunner;
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
-public class Olingo2SampleApplicationTests {
+public class Olingo2SampleApplicationUnitTest {
 
 	@Test
 	public void contextLoads() {

apache-pulsar/pom.xml

@@ -7,6 +7,13 @@
     <version>0.0.1</version>
     <name>apache-pulsar</name>
 
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
     <dependencies>
         <dependency>
             <groupId>org.apache.pulsar</groupId>

apache-pulsar/src/main/java/com/baeldung/ConsumerUnitTest.java

@@ -7,7 +7,7 @@ import org.apache.pulsar.client.api.Message;
 import org.apache.pulsar.client.api.PulsarClient;
 import org.apache.pulsar.client.api.SubscriptionType;
 
-public class ConsumerTest {
+public class ConsumerUnitTest {
 
     private static final String SERVICE_URL = "pulsar://localhost:6650";
     private static final String TOPIC_NAME = "test-topic";

apache-pulsar/src/main/java/com/baeldung/ProducerUnitTest.java

@@ -11,7 +11,7 @@ import org.apache.pulsar.client.api.PulsarClientException;
 import java.io.IOException;
 import java.util.stream.IntStream;
 
-public class ProducerTest {
+public class ProducerUnitTest {
 
     private static final String SERVICE_URL = "pulsar://localhost:6650";
     private static final String TOPIC_NAME = "test-topic";

apache-pulsar/src/main/java/com/baeldung/subscriptions/ExclusiveSubscriptionUnitTest.java

@@ -10,7 +10,7 @@ import org.apache.pulsar.client.api.SubscriptionType;
 
 import java.util.stream.IntStream;
 
-public class ExclusiveSubscriptionTest {
+public class ExclusiveSubscriptionUnitTest {
     private static final String SERVICE_URL = "pulsar://localhost:6650";
     private static final String TOPIC_NAME = "test-topic";
     private static final String SUBSCRIPTION_NAME = "test-subscription";

apache-pulsar/src/main/java/com/baeldung/subscriptions/FailoverSubscriptionUnitTest.java

@@ -11,7 +11,7 @@ import org.apache.pulsar.client.api.SubscriptionType;
 
 import java.util.stream.IntStream;
 
-public class FailoverSubscriptionTest {
+public class FailoverSubscriptionUnitTest {
     private static final String SERVICE_URL = "pulsar://localhost:6650";
     private static final String TOPIC_NAME = "failover-subscription-test-topic";
     private static final String SUBSCRIPTION_NAME = "test-subscription";

apache-spark/pom.xml

@@ -49,6 +49,7 @@
 			<version>${com.datastax.spark.spark-cassandra-connector-java.version}</version>
 		</dependency>
     </dependencies>
+
 	<build>
     	<plugins>
     	  	<plugin>
@@ -78,6 +79,7 @@
       		</plugin>
    		</plugins>
   	</build>
+
     <properties>
         <org.apache.spark.spark-core.version>2.3.0</org.apache.spark.spark-core.version>
         <org.apache.spark.spark-sql.version>2.3.0</org.apache.spark.spark-sql.version>

autovalue/README.md

@@ -1,3 +1,4 @@
 ### Relevant Articles:
 - [Introduction to AutoValue](http://www.baeldung.com/introduction-to-autovalue)
 - [Introduction to AutoFactory](http://www.baeldung.com/autofactory)
+- [Google AutoService](https://www.baeldung.com/google-autoservice)

autovalue/pom.xml

@@ -29,6 +29,12 @@
                 </exclusion>
             </exclusions>
         </dependency>
+        <dependency>
+            <groupId>com.google.auto.service</groupId>
+            <artifactId>auto-service</artifactId>
+            <version>${auto-service.version}</version>
+            <optional>true</optional>
+        </dependency>
 
         <dependency>
             <groupId>com.google.inject</groupId>
@@ -40,6 +46,7 @@
     <properties>
         <auto-value.version>1.3</auto-value.version>
         <auto-factory.version>1.0-beta5</auto-factory.version>
+        <auto-service.version>1.0-rc5</auto-service.version>
         <guice.version>4.2.0</guice.version>
     </properties>
 

autovalue/src/main/java/com/baeldung/autoservice/BingTranslationServiceProvider.java

@@ -0,0 +1,14 @@
+package com.baeldung.autoservice;
+
+import com.google.auto.service.AutoService;
+
+import java.util.Locale;
+
+@AutoService(TranslationService.class)
+public class BingTranslationServiceProvider implements TranslationService {
+    @Override
+    public String translate(String message, Locale from, Locale to) {
+        // implementation details
+        return message + " (translated by Bing)"; 
+    }
+}

autovalue/src/main/java/com/baeldung/autoservice/GoogleTranslationServiceProvider.java

@@ -0,0 +1,14 @@
+package com.baeldung.autoservice;
+
+import com.google.auto.service.AutoService;
+
+import java.util.Locale;
+
+@AutoService(TranslationService.class)
+public class GoogleTranslationServiceProvider implements TranslationService {
+    @Override
+    public String translate(String message, Locale from, Locale to) {
+        // implementation details
+        return message + " (translated by Google)"; 
+    }
+}

autovalue/src/main/java/com/baeldung/autoservice/TranslationService.java

@@ -0,0 +1,7 @@
+package com.baeldung.autoservice;
+
+import java.util.Locale;
+
+public interface TranslationService {
+    String translate(String message, Locale from, Locale to);
+}

autovalue/src/test/java/com/baeldung/autoservice/TranslationServiceUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.autoservice;
+
+import com.baeldung.autoservice.TranslationService;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ServiceLoader;
+import java.util.stream.StreamSupport;
+
+import static org.junit.Assert.assertEquals;
+
+public class TranslationServiceUnitTest {
+
+    private ServiceLoader<TranslationService> loader;
+
+    @Before
+    public void setUp() {
+        loader = ServiceLoader.load(TranslationService.class);
+    }
+
+    @Test
+    public void whenServiceLoaderLoads_thenLoadsAllProviders() {
+        long count = StreamSupport.stream(loader.spliterator(), false).count();
+        assertEquals(2, count);
+    }
+
+    @Test
+    public void whenServiceLoaderLoadsGoogleService_thenGoogleIsLoaded() {
+        TranslationService googleService = StreamSupport.stream(loader.spliterator(), false)
+          .filter(p -> p.getClass().getSimpleName().equals("GoogleTranslationServiceProvider"))
+          .findFirst()
+          .get();
+		
+        String message = "message";
+        assertEquals(message + " (translated by Google)", googleService.translate(message, null, null));
+    }
+}

aws/pom.xml

@@ -112,7 +112,6 @@
     </repositories>
 
     <properties>
-        <commons-io.version>2.5</commons-io.version>
         <aws-lambda-java-events.version>1.3.0</aws-lambda-java-events.version>
         <aws-lambda-java-core.version>1.1.0</aws-lambda-java-core.version>
         <gson.version>2.8.0</gson.version>

axon/pom.xml

@@ -18,12 +18,6 @@
             <groupId>org.axonframework</groupId>
             <artifactId>axon-spring-boot-starter</artifactId>
             <version>${axon.version}</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.axonframework</groupId>
-                    <artifactId>axon-server-connector</artifactId>
-                </exclusion>
-            </exclusions>
         </dependency>
 
         <dependency>
@@ -58,7 +52,7 @@
     </dependencies>
 
     <properties>
-        <axon.version>4.0.3</axon.version>
+        <axon.version>4.1.2</axon.version>
     </properties>
 
 </project>

axon/src/main/java/com/baeldung/axon/commandmodel/OrderAggregate.java

@@ -13,6 +13,7 @@ import com.baeldung.axon.coreapi.commands.ShipOrderCommand;
 import com.baeldung.axon.coreapi.events.OrderConfirmedEvent;
 import com.baeldung.axon.coreapi.events.OrderPlacedEvent;
 import com.baeldung.axon.coreapi.events.OrderShippedEvent;
+import com.baeldung.axon.coreapi.exceptions.UnconfirmedOrderException;
 
 @Aggregate
 public class OrderAggregate {
@@ -34,7 +35,7 @@ public class OrderAggregate {
     @CommandHandler
     public void handle(ShipOrderCommand command) {
         if (!orderConfirmed) {
-            throw new IllegalStateException("Cannot ship an order which has not been confirmed yet.");
+            throw new UnconfirmedOrderException();
         }
 
         apply(new OrderShippedEvent(orderId));
@@ -43,12 +44,12 @@ public class OrderAggregate {
     @EventSourcingHandler
     public void on(OrderPlacedEvent event) {
         this.orderId = event.getOrderId();
-        orderConfirmed = false;
+        this.orderConfirmed = false;
     }
 
     @EventSourcingHandler
     public void on(OrderConfirmedEvent event) {
-        orderConfirmed = true;
+        this.orderConfirmed = true;
     }
 
     protected OrderAggregate() {

axon/src/main/java/com/baeldung/axon/coreapi/exceptions/UnconfirmedOrderException.java

@@ -0,0 +1,8 @@
+package com.baeldung.axon.coreapi.exceptions;
+
+public class UnconfirmedOrderException extends IllegalStateException {
+
+    public UnconfirmedOrderException() {
+        super("Cannot ship an order which has not been confirmed yet.");
+    }
+}

axon/src/main/java/com/baeldung/axon/querymodel/OrderedProductsEventHandler.java

@@ -5,6 +5,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import org.axonframework.config.ProcessingGroup;
 import org.axonframework.eventhandling.EventHandler;
 import org.axonframework.queryhandling.QueryHandler;
 import org.springframework.stereotype.Service;
@@ -16,6 +17,7 @@ import com.baeldung.axon.coreapi.queries.FindAllOrderedProductsQuery;
 import com.baeldung.axon.coreapi.queries.OrderedProduct;
 
 @Service
+@ProcessingGroup("ordered-products")
 public class OrderedProductsEventHandler {
 
     private final Map<String, OrderedProduct> orderedProducts = new HashMap<>();

axon/src/main/resources/application.properties

@@ -0,0 +1 @@
+spring.application.name=Order Management Service

axon/src/test/java/com/baeldung/axon/commandmodel/OrderAggregateUnitTest.java

@@ -2,6 +2,7 @@ package com.baeldung.axon.commandmodel;
 
 import java.util.UUID;
 
+import com.baeldung.axon.coreapi.exceptions.UnconfirmedOrderException;
 import org.axonframework.test.aggregate.AggregateTestFixture;
 import org.axonframework.test.aggregate.FixtureConfiguration;
 import org.junit.*;
@@ -41,12 +42,12 @@ public class OrderAggregateUnitTest {
     }
 
     @Test
-    public void givenOrderPlacedEvent_whenShipOrderCommand_thenShouldThrowIllegalStateException() {
+    public void givenOrderPlacedEvent_whenShipOrderCommand_thenShouldThrowUnconfirmedOrderException() {
         String orderId = UUID.randomUUID().toString();
         String product = "Deluxe Chair";
         fixture.given(new OrderPlacedEvent(orderId, product))
                .when(new ShipOrderCommand(orderId))
-               .expectException(IllegalStateException.class);
+               .expectException(UnconfirmedOrderException.class);
     }
 
     @Test

bootique/pom.xml

@@ -65,7 +65,6 @@
     <properties>
         <main.class>com.baeldung.bootique.App</main.class>
         <bootique-bom.version>0.23</bootique-bom.version>
-
         <maven-shade-plugin.version>2.4.3</maven-shade-plugin.version>
     </properties>
 

core-groovy-2/README.md

@@ -3,5 +3,8 @@
 ## Relevant articles:
 
 - [String Matching in Groovy](http://www.baeldung.com/)
+- [Template Engines in Groovy](https://www.baeldung.com/groovy-template-engines)
 - [Groovy def Keyword](https://www.baeldung.com/groovy-def-keyword)
 - [Pattern Matching in Strings in Groovy](https://www.baeldung.com/groovy-pattern-matching)
+- [Working with XML in Groovy](https://www.baeldung.com/groovy-xml)
+- [Integrating Groovy into Java Applications](https://www.baeldung.com/groovy-java-applications)

core-groovy-2/gmavenplus-pom.xml

@@ -0,0 +1,178 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-groovy-2</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <name>core-groovy-2</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>${logback.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.codehaus.groovy</groupId>
+            <artifactId>groovy-all</artifactId>
+            <version>${groovy.version}</version>
+            <type>pom</type>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-runner</artifactId>
+            <version>${junit.platform.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hsqldb</groupId>
+            <artifactId>hsqldb</artifactId>
+            <version>${hsqldb.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.spockframework</groupId>
+            <artifactId>spock-core</artifactId>
+            <version>${spock-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <scriptSourceDirectory>src/main/groovy</scriptSourceDirectory>
+        <sourceDirectory>src/main/java</sourceDirectory>
+        <plugins>
+            <plugin>
+                <groupId>org.codehaus.gmavenplus</groupId>
+                <artifactId>gmavenplus-plugin</artifactId>
+                <version>1.7.0</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>execute</goal>
+                            <goal>addSources</goal>
+                            <goal>addTestSources</goal>
+                            <goal>generateStubs</goal>
+                            <goal>compile</goal>
+                            <goal>generateTestStubs</goal>
+                            <goal>compileTests</goal>
+                            <goal>removeStubs</goal>
+                            <goal>removeTestStubs</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.codehaus.groovy</groupId>
+                        <artifactId>groovy-all</artifactId>
+                        <!-- any version of Groovy \>= 1.5.0 should work here -->
+                        <version>${groovy.version}</version>
+                        <scope>runtime</scope>
+                        <type>pom</type>
+                    </dependency>
+                </dependencies>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>${maven-failsafe-plugin.version}</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.junit.platform</groupId>
+                        <artifactId>junit-platform-surefire-provider</artifactId>
+                        <version>${junit.platform.version}</version>
+                    </dependency>
+                </dependencies>
+                <executions>
+                    <execution>
+                        <id>junit5</id>
+                        <goals>
+                            <goal>integration-test</goal>
+                            <goal>verify</goal>
+                        </goals>
+                        <configuration>
+                            <includes>
+                                <include>**/*Test5.java</include>
+                            </includes>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.20.1</version>
+                <configuration>
+                <useFile>false</useFile>
+                <includes>
+                    <include>**/*Test.java</include>
+                    <include>**/*Spec.java</include>
+                </includes>
+                </configuration>
+            </plugin>
+            <!-- Maven Assembly Plugin: needed to run the jar through command line -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>3.1.0</version>
+                <configuration>
+                    <!-- get all project dependencies -->
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                    <!-- MainClass in mainfest make a executable jar -->
+                    <archive>
+                        <manifest>
+                            <mainClass>com.baeldung.MyJointCompilationApp</mainClass>
+                        </manifest>
+                    </archive>
+
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id>
+                        <!-- bind to the packaging phase -->
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <repositories>
+        <repository>
+            <id>central</id>
+            <url>http://jcenter.bintray.com</url>
+        </repository>
+    </repositories>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <junit.platform.version>1.0.0</junit.platform.version>
+        <hsqldb.version>2.4.0</hsqldb.version>
+        <spock-core.version>1.1-groovy-2.4</spock-core.version>
+        <commons-lang3.version>3.9</commons-lang3.version>
+        <java.version>1.8</java.version>
+        <logback.version>1.2.3</logback.version>
+        <groovy.version>2.5.7</groovy.version>
+        <gmavenplus-plugin.version>1.6</gmavenplus-plugin.version>
+    </properties>
+</project>
+

core-groovy-2/pom.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>core-groovy-2</artifactId>
     <version>1.0-SNAPSHOT</version>
@@ -15,25 +15,20 @@
 
     <dependencies>
         <dependency>
-            <groupId>org.codehaus.groovy</groupId>
-            <artifactId>groovy</artifactId>
-            <version>${groovy.version}</version>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>${logback.version}</version>
         </dependency>
         <dependency>
             <groupId>org.codehaus.groovy</groupId>
             <artifactId>groovy-all</artifactId>
-            <version>${groovy-all.version}</version>
-            <type>pom</type>
-        </dependency>
-        <dependency>
-            <groupId>org.codehaus.groovy</groupId>
-            <artifactId>groovy-dateutil</artifactId>
             <version>${groovy.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.codehaus.groovy</groupId>
-            <artifactId>groovy-sql</artifactId>
-            <version>${groovy-sql.version}</version>
+            <type>pom</type>
         </dependency>
         <dependency>
             <groupId>org.junit.platform</groupId>
@@ -56,21 +51,35 @@
     </dependencies>
 
     <build>
+        <scriptSourceDirectory>src/main/groovy</scriptSourceDirectory>
+        <sourceDirectory>src/main/java</sourceDirectory>
         <plugins>
             <plugin>
-                <groupId>org.codehaus.gmavenplus</groupId>
-                <artifactId>gmavenplus-plugin</artifactId>
-                <version>${gmavenplus-plugin.version}</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>addSources</goal>
-                            <goal>addTestSources</goal>
-                            <goal>compile</goal>
-                            <goal>compileTests</goal>
-                        </goals>
-                    </execution>
-                </executions>
+                <groupId>org.codehaus.groovy</groupId>
+                <artifactId>groovy-eclipse-compiler</artifactId>
+                <version>3.3.0-01</version>
+                <extensions>true</extensions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.8.0</version>
+                <configuration>
+                    <compilerId>groovy-eclipse-compiler</compilerId>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                </configuration>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.codehaus.groovy</groupId>
+                        <artifactId>groovy-eclipse-compiler</artifactId>
+                        <version>3.3.0-01</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.codehaus.groovy</groupId>
+                        <artifactId>groovy-eclipse-batch</artifactId>
+                        <version>${groovy.version}-01</version>
+                    </dependency>
+                </dependencies>
             </plugin>
             <plugin>
                 <artifactId>maven-failsafe-plugin</artifactId>
@@ -101,13 +110,42 @@
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>2.20.1</version>
                 <configuration>
-                <useFile>false</useFile>
-                <includes>
-                    <include>**/*Test.java</include>
-                    <include>**/*Spec.java</include>
-                </includes>
+                    <useFile>false</useFile>
+                    <includes>
+                        <include>**/*Test.java</include>
+                        <include>**/*Spec.java</include>
+                    </includes>
                 </configuration>
             </plugin>
+            <!-- Maven Assembly Plugin: needed to run the jar through command line -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>3.1.0</version>
+                <configuration>
+                    <!-- get all project dependencies -->
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                    <!-- MainClass in mainfest make a executable jar -->
+                    <archive>
+                        <manifest>
+                            <mainClass>com.baeldung.MyJointCompilationApp</mainClass>
+                        </manifest>
+                    </archive>
+
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id>
+                        <!-- bind to the packaging phase -->
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 
@@ -118,14 +156,29 @@
         </repository>
     </repositories>
 
+    <pluginRepositories>
+        <pluginRepository>
+            <id>bintray</id>
+            <name>Groovy Bintray</name>
+            <url>https://dl.bintray.com/groovy/maven</url>
+            <releases>
+                <!-- avoid automatic updates -->
+                <updatePolicy>never</updatePolicy>
+            </releases>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </pluginRepository>
+    </pluginRepositories>
+
     <properties>
         <junit.platform.version>1.0.0</junit.platform.version>
-        <groovy.version>2.5.6</groovy.version>
-        <groovy-all.version>2.5.6</groovy-all.version>
-        <groovy-sql.version>2.5.6</groovy-sql.version>
         <hsqldb.version>2.4.0</hsqldb.version>
         <spock-core.version>1.1-groovy-2.4</spock-core.version>
-        <gmavenplus-plugin.version>1.6</gmavenplus-plugin.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+        <logback.version>1.2.3</logback.version>
+        <groovy.version>2.5.7</groovy.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 </project>
 

core-groovy-2/src/main/groovy/com/baeldung/CalcMath.groovy

@@ -0,0 +1,25 @@
+package com.baeldung
+
+import org.slf4j.LoggerFactory
+
+class CalcMath {
+    def log = LoggerFactory.getLogger(this.getClass())
+
+    def calcSum(x, y) {
+        log.info "Executing $x + $y"
+        x + y
+    }
+
+    /**
+     * example of method that in java would throw error at compile time
+     * @param x
+     * @param y
+     * @return
+     */
+    def calcSum2(x, y) {
+        log.info "Executing $x + $y"
+        // DANGER! This won't throw a compilation issue and fail only at runtime!!!
+        calcSum3()
+        log.info("Logging an undefined variable: $z")
+    }
+}

core-groovy-2/src/main/groovy/com/baeldung/CalcScript.groovy

@@ -0,0 +1,16 @@
+package com.baeldung
+
+def calcSum(x, y) {
+    x + y
+}
+
+def calcSum2(x, y) {
+    // DANGER! The variable "log" may be undefined
+    log.info "Executing $x + $y"
+    // DANGER! This method doesn't exist!
+    calcSum3()
+    // DANGER! The logged variable "z" is undefined!
+    log.info("Logging an undefined variable: $z")
+}
+
+calcSum(1,5)

core-groovy-2/src/main/groovy/com/baeldung/concatenate/Wonder.groovy

@@ -0,0 +1,52 @@
+package com.baeldung.concatenate
+
+class Wonder {
+
+    String numOfWonder = 'seven'
+
+    String operator_plus() {
+        return 'The ' + numOfWonder + ' wonders of the world'
+    }
+
+    String operator_left() {
+        return 'The ' << numOfWonder << ' wonders of ' << 'the world'
+    }
+
+    String interpolation_one() {
+        return "The $numOfWonder wonders of the world"
+
+    }
+
+    String interpolation_two() {
+        return "The ${numOfWonder} wonders of the world"
+    }
+
+    String multilineString() {
+        return """
+            There are $numOfWonder wonders of the world.
+            Can you name them all? 
+            1. The Great Pyramid of Giza
+            2. Hanging Gardens of Babylon
+            3. Colossus of Rhode
+            4. Lighthouse of Alexendra
+            5. Temple of Artemis
+            6. Status of Zeus at Olympia
+            7. Mausoleum at Halicarnassus
+        """
+    }
+
+    String method_concat() {
+        return 'The '.concat(numOfWonder).concat(' wonders of the world')
+
+    }
+
+    String method_builder() {
+        return new StringBuilder()
+                .append('The ').append(numOfWonder).append(' wonders of the world')
+    }
+
+    String method_buffer() {
+        return new StringBuffer()
+                .append('The ').append(numOfWonder).append(' wonders of the world')
+    }
+}

core-groovy-2/src/main/java/com/baeldung/MyJointCompilationApp.java

@@ -0,0 +1,120 @@
+package com.baeldung;
+
+import groovy.lang.*;
+import groovy.util.GroovyScriptEngine;
+import groovy.util.ResourceException;
+import groovy.util.ScriptException;
+import org.codehaus.groovy.jsr223.GroovyScriptEngineFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import javax.script.ScriptEngine;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * Hello world!
+ *
+ */
+public class MyJointCompilationApp {
+    private final static Logger LOG = LoggerFactory.getLogger(MyJointCompilationApp.class);
+    private final GroovyClassLoader loader;
+    private final GroovyShell shell;
+    private final GroovyScriptEngine engine;
+    private final ScriptEngine engineFromFactory;
+
+    public MyJointCompilationApp() {
+        loader = new GroovyClassLoader(this.getClass().getClassLoader());
+        shell = new GroovyShell(loader, new Binding());
+
+        URL url = null;
+        try {
+            url = new File("src/main/groovy/com/baeldung/").toURI().toURL();
+        } catch (MalformedURLException e) {
+            LOG.error("Exception while creating url", e);
+        }
+        engine = new GroovyScriptEngine(new URL[] {url}, this.getClass().getClassLoader());
+        engineFromFactory = new GroovyScriptEngineFactory().getScriptEngine();
+    }
+
+    private void addWithCompiledClasses(int x, int y) {
+        LOG.info("Executing {} + {}", x, y);
+        Object result1 = new CalcScript().calcSum(x, y);
+        LOG.info("Result of CalcScript.calcSum() method is {}", result1);
+
+        Object result2 = new CalcMath().calcSum(x, y);
+        LOG.info("Result of CalcMath.calcSum() method is {}", result2);
+    }
+
+    private void addWithGroovyShell(int x, int y) throws IOException {
+        Script script = shell.parse(new File("src/main/groovy/com/baeldung/", "CalcScript.groovy"));
+        LOG.info("Executing {} + {}", x, y);
+        Object result = script.invokeMethod("calcSum", new Object[] { x, y });
+        LOG.info("Result of CalcScript.calcSum() method is {}", result);
+    }
+
+    private void addWithGroovyShellRun() throws IOException {
+        Script script = shell.parse(new File("src/main/groovy/com/baeldung/", "CalcScript.groovy"));
+        LOG.info("Executing script run method");
+        Object result = script.run();
+        LOG.info("Result of CalcScript.run() method is {}", result);
+    }
+
+    private void addWithGroovyClassLoader(int x, int y) throws IllegalAccessException, InstantiationException, IOException {
+        Class calcClass = loader.parseClass(
+          new File("src/main/groovy/com/baeldung/", "CalcMath.groovy"));
+        GroovyObject calc = (GroovyObject) calcClass.newInstance();
+        Object result = calc.invokeMethod("calcSum", new Object[] { x + 14, y + 14 });
+        LOG.info("Result of CalcMath.calcSum() method is {}", result);
+    }
+
+    private void addWithGroovyScriptEngine(int x, int y) throws IllegalAccessException,
+      InstantiationException, ResourceException, ScriptException {
+        Class<GroovyObject> calcClass = engine.loadScriptByName("CalcMath.groovy");
+        GroovyObject calc = calcClass.newInstance();
+        //WARNING the following will throw a ClassCastException
+        //((CalcMath)calc).calcSum(1,2);
+        Object result = calc.invokeMethod("calcSum", new Object[] { x, y });
+        LOG.info("Result of CalcMath.calcSum() method is {}", result);
+    }
+
+    private void addWithEngineFactory(int x, int y) throws IllegalAccessException,
+      InstantiationException, javax.script.ScriptException, FileNotFoundException {
+        Class calcClass = (Class) engineFromFactory.eval(
+          new FileReader(new File("src/main/groovy/com/baeldung/", "CalcMath.groovy")));
+        GroovyObject calc = (GroovyObject) calcClass.newInstance();
+        Object result = calc.invokeMethod("calcSum", new Object[] { x, y });
+        LOG.info("Result of CalcMath.calcSum() method is {}", result);
+    }
+
+    private void addWithStaticCompiledClasses() {
+        LOG.info("Running the Groovy classes compiled statically...");
+        addWithCompiledClasses(5, 10);
+
+    }
+
+    private void addWithDynamicCompiledClasses() throws IOException, IllegalAccessException, InstantiationException,
+      ResourceException, ScriptException, javax.script.ScriptException {
+        LOG.info("Invocation of a dynamic groovy script...");
+        addWithGroovyShell(5, 10);
+        LOG.info("Invocation of the run method of a dynamic groovy script...");
+        addWithGroovyShellRun();
+        LOG.info("Invocation of a dynamic groovy class loaded with GroovyClassLoader...");
+        addWithGroovyClassLoader(10, 30);
+        LOG.info("Invocation of a dynamic groovy class loaded with GroovyScriptEngine...");
+        addWithGroovyScriptEngine(15, 0);
+        LOG.info("Invocation of a dynamic groovy class loaded with GroovyScriptEngine JSR223...");
+        addWithEngineFactory(5, 6);
+    }
+
+    public static void main(String[] args) throws InstantiationException, IllegalAccessException,
+      ResourceException, ScriptException, IOException, javax.script.ScriptException {
+        MyJointCompilationApp myJointCompilationApp = new MyJointCompilationApp();
+        LOG.info("Example of addition operation via Groovy scripts integration with Java.");
+        myJointCompilationApp.addWithStaticCompiledClasses();
+        myJointCompilationApp.addWithDynamicCompiledClasses();
+    }
+}

core-groovy-2/src/test/groovy/com/baeldung/concatenate/WonderUnitTest.groovy

@@ -0,0 +1,69 @@
+package com.baeldung.concatenate
+
+import org.junit.Before
+import org.junit.Test
+
+import static org.junit.Assert.*
+
+class WonderUnitTest {
+
+    static final String EXPECTED_SINGLE_LINE = "The seven wonders of the world"
+
+    Wonder wonder
+
+    @Before
+    void before() {
+        wonder = new Wonder()
+    }
+
+    @Test
+    void whenUsingOperatorPlus_thenConcatCorrectly() {
+        assertEquals(EXPECTED_SINGLE_LINE, wonder.operator_plus())
+    }
+
+    @Test
+    void whenUsingOperatorLeft_thenConcatCorrectly() {
+        assertEquals(EXPECTED_SINGLE_LINE, wonder.operator_left())
+    }
+
+    @Test
+    void whenUsingInterpolationOne_thenConcatCorrectly() {
+        assertEquals(EXPECTED_SINGLE_LINE, wonder.interpolation_one())
+    }
+
+    @Test
+    void whenUsingInterpolationTwo_thenConcatCorrectly() {
+        assertEquals(EXPECTED_SINGLE_LINE, wonder.interpolation_two())
+    }
+
+    @Test
+    void whenUsingMultiline_thenConcatCorrectly() {
+        def expectedMultiline = """
+            There are seven wonders of the world.
+            Can you name them all? 
+            1. The Great Pyramid of Giza
+            2. Hanging Gardens of Babylon
+            3. Colossus of Rhode
+            4. Lighthouse of Alexendra
+            5. Temple of Artemis
+            6. Status of Zeus at Olympia
+            7. Mausoleum at Halicarnassus
+        """
+        assertEquals(expectedMultiline, wonder.multilineString())
+    }
+
+    @Test
+    void whenUsingMethodConcat_thenConcatCorrectly() {
+        assertEquals(EXPECTED_SINGLE_LINE, wonder.method_concat())
+    }
+
+    @Test
+    void whenUsingMethodBuilder_thenConcatCorrectly() {
+        assertEquals(EXPECTED_SINGLE_LINE, wonder.method_builder())
+    }
+
+    @Test
+    void whenUsingMethodBuffer_thenConcatCorrectly() {
+        assertEquals(EXPECTED_SINGLE_LINE, wonder.method_buffer())
+    }
+}

core-java-modules/README.md

@@ -1,3 +1,6 @@
 ## Relevant articles:
 
 - [Multi-Module Maven Application with Java Modules](https://www.baeldung.com/maven-multi-module-project-java-jpms)
+- [Guide to Java FileChannel](https://www.baeldung.com/java-filechannel)
+- [Understanding the NumberFormatException in Java](https://www.baeldung.com/java-number-format-exception)
+- [Will an Error Be Caught by Catch Block in Java?](https://www.baeldung.com/java-error-catch)

core-java-modules/core-java-10/README.md

@@ -5,3 +5,4 @@
 - [Guide to Java 10](http://www.baeldung.com/java-10-overview)
 - [Copy a List to Another List in Java](http://www.baeldung.com/java-copy-list-to-another)
 - [Deep Dive Into the New Java JIT Compiler – Graal](https://www.baeldung.com/graal-java-jit-compiler)
+- [Copying Sets in Java](https://www.baeldung.com/java-copy-sets)

core-java-modules/core-java-10/src/main/java/com/baeldung/set/CopySets.java

@@ -0,0 +1,13 @@
+package com.baeldung.set;
+
+import java.util.Set;
+
+public class CopySets {
+
+    // Using Java 10
+    public static <T> Set<T> copyBySetCopyOf(Set<T> original) {
+        Set<T> copy = Set.copyOf(original);
+        return copy;
+    }
+
+}

core-java-modules/core-java-11/README.md

@@ -7,4 +7,5 @@
 - [Exploring the New HTTP Client in Java 9 and 11](https://www.baeldung.com/java-9-http-client)
 - [An Introduction to Epsilon GC: A No-Op Experimental Garbage Collector](https://www.baeldung.com/jvm-epsilon-gc-garbage-collector)
 - [Guide to jlink](https://www.baeldung.com/jlink)
+- [Negate a Predicate Method Reference with Java 11](https://www.baeldung.com/java-negate-predicate-method-reference)
 - [Transforming an Empty String into an Empty Optional](https://www.baeldung.com/java-empty-string-to-empty-optional)

core-java-modules/core-java-11/src/main/java/com/baeldung/predicate/not/README.md

@@ -0,0 +1,3 @@
+## Relevant articles:
+
+- [Negate a Predicate Method Reference with Java 11](https://www.baeldung.com/java-negate-predicate-method-reference)

core-java-modules/core-java-12/README.md

@@ -0,0 +1,4 @@
+## Relevant Articles:
+
+
+- [String API Updates in Java 12](https://www.baeldung.com/java12-string-api)

core-java-modules/core-java-8-2/README.md

@@ -3,5 +3,7 @@
 ## Core Java 8 Cookbooks and Examples (part 2)
 
 ### Relevant Articles: 
-- [Anonymous Classes in Java](https://www.baeldung.com/java-anonymous-classes)
+- [Anonymous Classes in Java](http://www.baeldung.com/)
+- [How to Delay Code Execution in Java](https://www.baeldung.com/java-delay-code-execution)
 - [Run JAR Application With Command Line Arguments](https://www.baeldung.com/java-run-jar-with-arguments)
+- [Java 8 Stream skip() vs limit()](https://www.baeldung.com/java-stream-skip-vs-limit)

core-java-modules/core-java-8-2/pom.xml

@@ -9,7 +9,6 @@
     <name>core-java-8-2</name>
     <packaging>jar</packaging>
 
-
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-java</artifactId>
@@ -17,16 +16,6 @@
         <relativePath>../../parent-java</relativePath>
     </parent>
 
-    <properties>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
-        <icu.version>64.2</icu.version>
-        <hibernate.core.version>5.4.0.Final</hibernate.core.version>
-        <h2database.version>1.4.197</h2database.version>
-        <jackson.databind.version>2.9.8</jackson.databind.version>
-    </properties>
-
     <dependencies>
         <dependency>
             <groupId>com.ibm.icu</groupId>
@@ -34,19 +23,10 @@
             <version>${icu.version}</version>
         </dependency>
         <dependency>
-            <groupId>org.hibernate</groupId>
-            <artifactId>hibernate-core</artifactId>
-            <version>${hibernate.core.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <version>${h2database.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-            <version>${jackson.databind.version}</version>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
         </dependency>
     </dependencies>
 
@@ -62,6 +42,13 @@
                 </configuration>
             </plugin>
         </plugins>
-
     </build>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <icu.version>64.2</icu.version>
+        <assertj.version>3.12.2</assertj.version>
+    </properties>
 </project>

core-java-modules/core-java-8-2/src/main/java/com/baeldung/forEach/ReverseList.java

@@ -0,0 +1,84 @@
+package com.baeldung.forEach;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Consumer;
+
+class ReverseList extends ArrayList<String> {
+
+    List<String> list = Arrays.asList("A", "B", "C", "D");
+
+    Consumer<String> removeElement = s -> {
+        System.out.println(s + " " + list.size());
+        if (s != null && s.equals("A")) {
+            list.remove("D");
+        }
+    };
+
+    @Override
+    public Iterator<String> iterator() {
+
+        final int startIndex = this.size() - 1;
+        final List<String> list = this;
+        return new Iterator<String>() {
+
+            int currentIndex = startIndex;
+
+            @Override
+            public boolean hasNext() {
+                return currentIndex >= 0;
+            }
+
+            @Override
+            public String next() {
+                String next = list.get(currentIndex);
+                currentIndex--;
+                return next;
+            }
+
+            @Override
+            public void remove() {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+
+    public void forEach(Consumer<? super String> action) {
+        for (String s : this) {
+            action.accept(s);
+        }
+    }
+
+    public void iterateParallel() {
+        list.forEach(System.out::print);
+        System.out.print(" ");
+        list.parallelStream().forEach(System.out::print);
+    }
+
+    public void iterateReverse() {
+        List<String> myList = new ReverseList();
+        myList.addAll(list);
+        myList.forEach(System.out::print);
+        System.out.print(" ");
+        myList.stream().forEach(System.out::print);
+    }
+
+    public void removeInCollectionForEach() {
+        list.forEach(removeElement);
+    }
+
+    public void removeInStreamForEach() {
+        list.stream().forEach(removeElement);
+    }
+
+    public static void main(String[] argv) {
+
+        ReverseList collectionForEach = new ReverseList();
+        collectionForEach.iterateParallel();
+        collectionForEach.iterateReverse();
+        collectionForEach.removeInCollectionForEach();
+        collectionForEach.removeInStreamForEach();
+    }
+}

core-java-modules/core-java-8-2/src/main/java/com/baeldung/stream/SkipLimitComparison.java

@@ -0,0 +1,46 @@
+package com.baeldung.stream;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class SkipLimitComparison {
+
+    public static void main(String[] args) {
+        skipExample();
+        limitExample();
+        limitInfiniteStreamExample();
+        getEvenNumbers(10, 10).stream()
+            .forEach(System.out::println);
+    }
+
+    public static void skipExample() {
+        Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+            .filter(i -> i % 2 == 0)
+            .skip(2)
+            .forEach(i -> System.out.print(i + " "));
+    }
+
+    public static void limitExample() {
+        Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+            .filter(i -> i % 2 == 0)
+            .limit(2)
+            .forEach(i -> System.out.print(i + " "));
+    }
+
+    public static void limitInfiniteStreamExample() {
+        Stream.iterate(0, i -> i + 1)
+            .filter(i -> i % 2 == 0)
+            .limit(10)
+            .forEach(System.out::println);
+    }
+
+    private static List<Integer> getEvenNumbers(int offset, int limit) {
+        return Stream.iterate(0, i -> i + 1)
+            .filter(i -> i % 2 == 0)
+            .skip(offset)
+            .limit(limit)
+            .collect(Collectors.toList());
+    }
+
+}

core-java-modules/core-java-8-2/src/test/java/com/baeldung/bifunction/BiFunctionalInterfacesUnitTest.java

@@ -0,0 +1,164 @@
+package com.baeldung.bifunction;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BiFunctionalInterfacesUnitTest {
+    @Test
+    public void givenStreamValues_whenMappedToNewValues() {
+        List<String> mapped = Stream.of("hello", "world")
+                .map(word -> word + "!")
+                .collect(Collectors.toList());
+
+        assertThat(mapped).containsExactly("hello!", "world!");
+    }
+
+    @Test
+    public void givenStreamValues_whenReducedWithPrefixingOperation() {
+        String result = Stream.of("hello", "world")
+                .reduce("", (a, b) -> b + "-" + a);
+
+        assertThat(result).isEqualTo("world-hello-");
+    }
+
+    @Test
+    public void givenStreamValues_whenReducedWithPrefixingLambda_thenHasNoTrailingDash() {
+        String result = Stream.of("hello", "world")
+                .reduce("", (a, b) -> combineWithoutTrailingDash(a, b));
+
+        assertThat(result).isEqualTo("world-hello");
+    }
+
+    private String combineWithoutTrailingDash(String a, String b) {
+        if (a.isEmpty()) {
+            return b;
+        }
+        return b + "-" + a;
+    }
+
+    @Test
+    public void givenStreamValues_whenReducedWithPrefixingMethodReference_thenHasNoTrailingDash() {
+        String result = Stream.of("hello", "world")
+                .reduce("", this::combineWithoutTrailingDash);
+
+        assertThat(result).isEqualTo("world-hello");
+    }
+
+    @Test
+    public void givenTwoLists_whenCombined() {
+        List<String> list1 = Arrays.asList("a", "b", "c");
+        List<Integer> list2 = Arrays.asList(1, 2, 3);
+
+        List<String> result = new ArrayList<>();
+        for (int i=0; i < list1.size(); i++) {
+            result.add(list1.get(i) + list2.get(i));
+        }
+
+        assertThat(result).containsExactly("a1", "b2", "c3");
+    }
+
+    @Test
+    public void givenTwoLists_whenCombinedWithGeneralPurposeCombiner() {
+        List<String> list1 = Arrays.asList("a", "b", "c");
+        List<Integer> list2 = Arrays.asList(1, 2, 3);
+
+        List<String> result = listCombiner(list1, list2, (a, b) -> a + b);
+
+        assertThat(result).containsExactly("a1", "b2", "c3");
+    }
+
+    private static <T, U, R> List<R> listCombiner(List<T> list1,
+                                                  List<U> list2,
+                                                  BiFunction<T, U, R> combiner) {
+        List<R> result = new ArrayList<>();
+        for (int i = 0; i < list1.size(); i++) {
+            result.add(combiner.apply(list1.get(i), list2.get(i)));
+        }
+        return result;
+    }
+
+    @Test
+    public void givenTwoLists_whenComparedWithCombiningFunction() {
+        List<Double> list1 = Arrays.asList(1.0d, 2.1d, 3.3d);
+        List<Float> list2 = Arrays.asList(0.1f, 0.2f, 4f);
+
+        // algorithm to determine if the value in list1 > value in list 2
+        List<Boolean> result = listCombiner(list1, list2, (a, b) -> a > b);
+
+        assertThat(result).containsExactly(true, true, false);
+    }
+
+    @Test
+    public void givenTwoLists_whenComparedWithCombiningFunctionByMethodReference() {
+        List<Double> list1 = Arrays.asList(1.0d, 2.1d, 3.3d);
+        List<Float> list2 = Arrays.asList(0.1f, 0.2f, 4f);
+
+        // algorithm to determine if the value in list1 > value in list 2
+        List<Boolean> result = listCombiner(list1, list2, this::firstIsGreaterThanSecond);
+
+        assertThat(result).containsExactly(true, true, false);
+    }
+
+    private boolean firstIsGreaterThanSecond(Double a, Float b) {
+        return a > b;
+    }
+
+    @Test
+    public void givenTwoLists_whenComparedForEqualityByCombiningFunction() {
+        List<Float> list1 = Arrays.asList(0.1f, 0.2f, 4f);
+        List<Float> list2 = Arrays.asList(0.1f, 0.2f, 4f);
+
+        List<Boolean> result = listCombiner(list1, list2, (a, b) -> a.equals(b));
+
+        assertThat(result).containsExactly(true, true, true);
+    }
+
+    @Test
+    public void givenTwoLists_whenComparedForEqualityByCombiningFunctionWithMethodReference() {
+        List<Float> list1 = Arrays.asList(0.1f, 0.2f, 4f);
+        List<Float> list2 = Arrays.asList(0.1f, 0.2f, 4f);
+
+        List<Boolean> result = listCombiner(list1, list2, Float::equals);
+
+        assertThat(result).containsExactly(true, true, true);
+    }
+
+    @Test
+    public void givenTwoLists_whenComparedWithCombiningFunctionWithCompareTo() {
+        List<Double> list1 = Arrays.asList(1.0d, 2.1d, 3.3d);
+        List<Double> list2 = Arrays.asList(0.1d, 0.2d, 4d);
+
+        List<Integer> result = listCombiner(list1, list2, Double::compareTo);
+
+        assertThat(result).containsExactly(1, 1, -1);
+    }
+
+    /**
+     * Allows you to to pass in a lambda or method reference and then
+     * get access to the BiFunction it is meant to become
+     */
+    private static <T, U, R> BiFunction<T, U, R> asBiFunction(BiFunction<T, U, R> function) {
+        return function;
+    }
+
+    @Test
+    public void givenTwoLists_whenComparedWithCombiningFunctionWithComposedBiFunction() {
+        List<Double> list1 = Arrays.asList(1.0d, 2.1d, 3.3d);
+        List<Double> list2 = Arrays.asList(0.1d, 0.2d, 4d);
+
+        List<Boolean> result = listCombiner(list1, list2,
+                asBiFunction(Double::compareTo)
+                    .andThen(i -> i > 0));
+
+        assertThat(result).containsExactly(true, true, false);
+    }
+}

core-java-modules/core-java-8/README.md

@@ -40,3 +40,4 @@
 - [Java 8 Predicate Chain](https://www.baeldung.com/java-predicate-chain)
 - [Method References in Java](https://www.baeldung.com/java-method-references)
 - [Creating a Custom Annotation in Java](https://www.baeldung.com/java-custom-annotation)
+- [The Difference Between Collection.stream().forEach() and Collection.forEach()](https://www.baeldung.com/java-collection-stream-foreach)

core-java-modules/core-java-8/pom.xml

@@ -175,7 +175,6 @@
 
     <properties>
         <!-- util -->
-        <commons-lang3.version>3.5</commons-lang3.version>
         <commons-math3.version>3.6.1</commons-math3.version>
         <commons-collections4.version>4.1</commons-collections4.version>
         <collections-generic.version>4.01</collections-generic.version>

core-java-modules/core-java-8/src/main/java/com/baeldung/java_8_features/groupingby/Tuple.java

@@ -0,0 +1,34 @@
+package com.baeldung.java_8_features.groupingby;
+
+public class Tuple {
+
+    private BlogPostType type;
+    private String author;
+    
+    public Tuple(BlogPostType type, String author) {
+        super();
+        this.type = type;
+        this.author = author;
+    }
+
+    public BlogPostType getType() {
+        return type;
+    }
+
+    public void setType(BlogPostType type) {
+        this.type = type;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public void setAuthor(String author) {
+        this.author = author;
+    }
+
+    @Override
+    public String toString() {
+        return "Tuple [type=" + type + ", author=" + author + ", getType()=" + getType() + ", getAuthor()=" + getAuthor() + ", getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()=" + super.toString() + "]";
+    }
+}

core-java-modules/core-java-8/src/test/java/com/baeldung/java8/optional/OptionalUnitTest.java

@@ -259,4 +259,15 @@ public class OptionalUnitTest {
         LOG.debug("Getting default value...");
         return "Default Value";
     }
+    
+//    Uncomment code when code base is compatiable with Java 11     
+//    @Test
+//    public void givenAnEmptyOptional_thenIsEmptyBehavesAsExpected() {
+//        Optional<String> opt = Optional.of("Baeldung");
+//        assertFalse(opt.isEmpty());
+//     
+//        opt = Optional.ofNullable(null);
+//        assertTrue(opt.isEmpty());
+//    }
+
 }

core-java-modules/core-java-arrays-2/.gitignore

@@ -0,0 +1,25 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml

core-java-modules/core-java-arrays-2/pom.xml

@@ -0,0 +1,50 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-arrays-2</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-arrays-2</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <!-- test scoped -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-arrays-2</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <properties>
+
+        <!-- util -->
+        <commons-lang3.version>3.9</commons-lang3.version>
+        <!-- testing -->
+        <assertj-core.version>3.10.0</assertj-core.version>
+    </properties>
+
+</project>

core-java-modules/core-java-arrays-2/src/main/java/com/baeldung/array/looping/LoopDiagonally.java

@@ -0,0 +1,45 @@
+package com.baeldung.array.looping;
+
+public class LoopDiagonally {
+
+
+    public String loopDiagonally(String[][] twoDArray) {
+
+        int length = twoDArray.length;
+        int diagonalLines = (length + length) - 1;
+        int itemsInDiagonal = 0;
+        int midPoint = (diagonalLines / 2) + 1;
+        StringBuilder output = new StringBuilder();
+
+        for (int i = 1; i <= diagonalLines; i++) {
+
+            StringBuilder items = new StringBuilder();
+            int rowIndex;
+            int columnIndex;
+
+            if (i <= midPoint) {
+                itemsInDiagonal++;
+                for (int j = 0; j < itemsInDiagonal; j++) {
+                    rowIndex = (i - j) - 1;
+                    columnIndex = j;
+                    items.append(twoDArray[rowIndex][columnIndex]);
+                }
+            } else {
+                itemsInDiagonal--;
+                for (int j = 0; j < itemsInDiagonal; j++) {
+                    rowIndex = (length - 1) - j;
+                    columnIndex = (i - length) + j;
+                    items.append(twoDArray[rowIndex][columnIndex]);
+                }
+            }
+
+            if (i != diagonalLines) {
+                output.append(items).append(" ");
+            } else {
+                output.append(items);
+            }
+        }
+
+        return output.toString();
+    }
+}

core-java-modules/core-java-arrays-2/src/test/java/com/baeldung/array/looping/LoopDiagonallyUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.array.looping;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class LoopDiagonallyUnitTest {
+
+    @Test
+    public void twoArrayIsLoopedDiagonallyAsExpected() {
+
+        LoopDiagonally loopDiagonally = new LoopDiagonally();
+        String[][] twoDArray = {{"a", "b", "c"},
+                                {"d", "e", "f"},
+                                {"g", "h", "i"}};
+
+        String output = loopDiagonally.loopDiagonally(twoDArray);
+        assertEquals("a db gec hf i", output);
+    }
+}

core-java-modules/core-java-arrays/README.md

@@ -15,3 +15,4 @@
 - [Intersection Between two Integer Arrays](https://www.baeldung.com/java-array-intersection)
 - [Sorting Arrays in Java](https://www.baeldung.com/java-sorting-arrays)
 - [Convert a Float to a Byte Array in Java](https://www.baeldung.com/java-convert-float-to-byte-array)
+- [Converting Between Stream and Array in Java](https://www.baeldung.com/java-stream-to-array)

core-java-modules/core-java-arrays/pom.xml

@@ -389,7 +389,7 @@
     <properties>
 
         <!-- util -->
-        <commons-lang3.version>3.8.1</commons-lang3.version>
+        <commons-lang3.version>3.9</commons-lang3.version>
         
         <jmh-core.version>1.19</jmh-core.version>
         <jmh-generator-annprocess.version>1.19</jmh-generator-annprocess.version>

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/RemoveElementFromAnArray.java

@@ -0,0 +1,27 @@
+package com.baeldung.array;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+public class RemoveElementFromAnArray {
+
+    public int[] removeAnElementWithAGivenIndex(int[] array, int index) {
+        return ArrayUtils.remove(array, index);
+    }
+
+    public int[] removeAllElementsWithGivenIndices(int[] array, int... indicies) {
+        return ArrayUtils.removeAll(array, indicies);
+    }
+
+    public int[] removeFirstOccurrenceOfGivenElement(int[] array, int element) {
+        return ArrayUtils.removeElement(array, element);
+    }
+
+    public int[] removeAllGivenElements(int[] array, int... elements) {
+        return ArrayUtils.removeElements(array, elements);
+    }
+
+    public int[] removeAllOccurrencesOfAGivenElement(int[] array, int element) {
+        return ArrayUtils.removeAllOccurences(array, element);
+    }
+
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/array/SortedArrayChecker.java

@@ -0,0 +1,65 @@
+package com.baeldung.array;
+
+import com.baeldung.arraycopy.model.Employee;
+
+import java.util.Comparator;
+
+public class SortedArrayChecker {
+
+    boolean isSorted(int[] array, int length) {
+        if (array == null || length < 2)
+            return true;
+
+        if (array[length - 2] > array[length - 1])
+            return false;
+
+        return isSorted(array, length - 1);
+    }
+
+    boolean isSorted(int[] array) {
+        for (int i = 0; i < array.length - 1; i++) {
+            if (array[i] > array[i + 1])
+                return false;
+        }
+
+        return true;
+    }
+
+    boolean isSorted(Comparable[] array, int length) {
+        if (array == null || length < 2)
+            return true;
+
+        if (array[length - 2].compareTo(array[length - 1]) > 0)
+            return false;
+
+        return isSorted(array, length - 1);
+    }
+
+    boolean isSorted(Comparable[] array) {
+        for (int i = 0; i < array.length - 1; ++i) {
+            if (array[i].compareTo(array[i + 1]) > 0)
+                return false;
+        }
+
+        return true;
+    }
+
+    boolean isSorted(Object[] array, Comparator comparator) {
+        for (int i = 0; i < array.length - 1; ++i) {
+            if (comparator.compare(array[i], (array[i + 1])) > 0)
+                return false;
+        }
+
+        return true;
+    }
+
+    boolean isSorted(Object[] array, Comparator comparator, int length) {
+        if (array == null || length < 2)
+            return true;
+
+        if (comparator.compare(array[length - 2], array[length - 1]) > 0)
+            return false;
+
+        return isSorted(array, comparator, length - 1);
+    }
+}

core-java-modules/core-java-arrays/src/main/java/com/baeldung/arraycopy/model/Employee.java

@@ -6,6 +6,7 @@ public class Employee implements Serializable {
     private static final long serialVersionUID = -2454619097207585825L;
     private int id;
     private String name;
+    private int age;
 
     public Employee() {
     }
@@ -15,10 +16,24 @@ public class Employee implements Serializable {
         this.name = name;
     }
 
+    public Employee(int id, String name, int age) {
+        this.id = id;
+        this.name = name;
+        this.age = age;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
     public int getId() {
         return id;
     }
 
+    public void setAge(int age) {
+        this.age = age;
+    }
+
     public void setId(int id) {
         this.id = id;
     }

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/RemoveElementFromAnArrayUnitTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.array;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.jupiter.api.Test;
+
+class RemoveElementFromAnArrayUnitTest {
+
+    private final RemoveElementFromAnArray sut = new RemoveElementFromAnArray();
+    private final int[] inputArray = new int[] { 40, 10, 20, 30, 40, 50 };
+
+    @Test
+    void testRemoveAnElementWithAGivenIndex() {
+        int index = 2;
+        int[] modifiedArray = sut.removeAnElementWithAGivenIndex(inputArray, index);
+
+        assertFalse(ArrayUtils.contains(modifiedArray, inputArray[index]));
+    }
+
+    @Test
+    void testRemoveAllElementsWithGivenIndices() {
+        int first = 0;
+        int last = inputArray.length - 1;
+        int[] modifiedArray = sut.removeAllElementsWithGivenIndices(inputArray, first, last);
+
+        assertFalse(ArrayUtils.contains(modifiedArray, inputArray[first]) && ArrayUtils.contains(modifiedArray, inputArray[last]));
+    }
+
+    @Test
+    void testRemoveElement_WhenArrayIsNull_ThrowsIndexOutOfBoundEx() {
+        int index = 2;
+
+        assertThrows(IndexOutOfBoundsException.class, () -> {
+            sut.removeAnElementWithAGivenIndex(null, index);
+        });
+
+        assertThrows(IndexOutOfBoundsException.class, () -> {
+            sut.removeAllElementsWithGivenIndices(null, index);
+        });
+    }
+
+    @Test
+    void testRemoveFirstOccurrenceOfGivenElement() {
+        int element = 40;
+        int[] modifiedArray = sut.removeFirstOccurrenceOfGivenElement(inputArray, element);
+
+        int indexInInputArray = ArrayUtils.indexOf(inputArray, element);
+        int indexInModifiedArray = ArrayUtils.indexOf(modifiedArray, element);
+        assertFalse(indexInInputArray == indexInModifiedArray);
+    }
+
+    @Test
+    void testRemoveAllGivenElements() {
+        int duplicateElement = 40;
+        int[] elements = new int[] { duplicateElement, 10, 50 };
+        int[] modifiedArray = sut.removeAllGivenElements(inputArray, elements);
+
+        assertTrue(ArrayUtils.contains(modifiedArray, duplicateElement));
+        assertFalse(ArrayUtils.contains(modifiedArray, elements[1]));
+        assertFalse(ArrayUtils.contains(modifiedArray, elements[2]));
+    }
+
+    @Test
+    void testRemoveAllOccurrencesOfAGivenElement() {
+        int element = 40;
+        int[] modifiedArray = sut.removeAllOccurrencesOfAGivenElement(inputArray, element);
+
+        assertFalse(ArrayUtils.contains(modifiedArray, element));
+    }
+
+    @Test
+    void testRemoveElement_WhenArrayIsNull_ReturnsNull() {
+        int element = 20;
+
+        assertEquals(null, sut.removeFirstOccurrenceOfGivenElement(null, element));
+        assertEquals(null, sut.removeAllGivenElements(null, element));
+        assertEquals(null, sut.removeAllOccurrencesOfAGivenElement(null, element));
+
+    }
+
+}

core-java-modules/core-java-arrays/src/test/java/com/baeldung/array/SortedArrayCheckerUnitTest.java

@@ -0,0 +1,79 @@
+package com.baeldung.array;
+
+import com.baeldung.arraycopy.model.Employee;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Comparator;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SortedArrayCheckerUnitTest {
+    private static final int[] INTEGER_SORTED = {1, 3, 5, 7, 9};
+    private static final int[] INTEGER_NOT_SORTED = {1, 3, 11, 7};
+
+    private static final String[] STRING_SORTED = {"abc", "cde", "fgh"};
+    private static final String[] STRING_NOT_SORTED = {"abc", "fgh", "cde", "ijk"};
+
+    private static final Employee[] EMPLOYEES_SORTED_BY_NAME = {
+            new Employee(1, "Carlos", 26),
+            new Employee(2, "Daniel", 31),
+            new Employee(3, "Marta", 27)};
+
+    private static final Employee[] EMPLOYEES_NOT_SORTED_BY_NAME = {
+            new Employee(1, "Daniel", 31),
+            new Employee(2, "Carlos", 26),
+            new Employee(3, "Marta", 27)};
+
+    private static final Employee[] EMPLOYEES_SORTED_BY_AGE = {
+            new Employee(1, "Carlos", 26),
+            new Employee(2, "Marta", 27),
+            new Employee(3, "Daniel", 31)};
+
+    private static final Employee[] EMPLOYEES_NOT_SORTED_BY_AGE = {
+            new Employee(1, "Marta", 27),
+            new Employee(2, "Carlos", 26),
+            new Employee(3, "Daniel", 31)};
+
+    private SortedArrayChecker sortedArrayChecker;
+
+    @Before
+    public void setup() {
+        sortedArrayChecker = new SortedArrayChecker();
+    }
+
+    @Test
+    public void givenIntegerArray_thenReturnIfItIsSortedOrNot() {
+        assertThat(sortedArrayChecker.isSorted(INTEGER_SORTED)).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(INTEGER_NOT_SORTED)).isEqualTo(false);
+
+        assertThat(sortedArrayChecker.isSorted(INTEGER_SORTED, INTEGER_SORTED.length)).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(INTEGER_NOT_SORTED, INTEGER_NOT_SORTED.length)).isEqualTo(false);
+    }
+
+    @Test
+    public void givenStringArray_thenReturnIfItIsSortedOrNot() {
+        assertThat(sortedArrayChecker.isSorted(STRING_SORTED)).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(STRING_NOT_SORTED)).isEqualTo(false);
+
+        assertThat(sortedArrayChecker.isSorted(STRING_SORTED, STRING_SORTED.length)).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(STRING_NOT_SORTED, STRING_NOT_SORTED.length)).isEqualTo(false);
+    }
+
+    @Test
+    public void givenEmployeeArray_thenReturnIfItIsSortedOrNot() {
+        assertThat(sortedArrayChecker.isSorted(EMPLOYEES_SORTED_BY_NAME, Comparator.comparing(Employee::getName))).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(EMPLOYEES_NOT_SORTED_BY_NAME, Comparator.comparing(Employee::getName))).isEqualTo(false);
+
+        assertThat(sortedArrayChecker.isSorted(EMPLOYEES_SORTED_BY_AGE, Comparator.comparingInt(Employee::getAge))).isEqualTo(true);
+        assertThat(sortedArrayChecker.isSorted(EMPLOYEES_NOT_SORTED_BY_AGE, Comparator.comparingInt(Employee::getAge))).isEqualTo(false);
+
+        assertThat(sortedArrayChecker
+                .isSorted(EMPLOYEES_SORTED_BY_AGE, Comparator.comparingInt(Employee::getAge), EMPLOYEES_SORTED_BY_AGE.length))
+                .isEqualTo(true);
+        assertThat(sortedArrayChecker
+                .isSorted(EMPLOYEES_NOT_SORTED_BY_AGE, Comparator.comparingInt(Employee::getAge), EMPLOYEES_NOT_SORTED_BY_AGE.length))
+                .isEqualTo(false);
+    }
+
+}

core-java-modules/core-java-collections-array-list/src/test/java/org/baeldung/java/collections/CoreJavaCollectionsUnitTest.java

@@ -42,7 +42,7 @@ public class CoreJavaCollectionsUnitTest {
     @Test(expected = UnsupportedOperationException.class)
     public final void givenUsingGuavaBuilder_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
         final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
-        final ImmutableList<Object> unmodifiableList = ImmutableList.builder().addAll(list).build();
+        final ImmutableList<String> unmodifiableList = ImmutableList.<String>builder().addAll(list).build();
         unmodifiableList.add("four");
     }
 

core-java-modules/core-java-collections-set/README.md

@@ -10,3 +10,4 @@
 - [Initializing HashSet at the Time of Construction](http://www.baeldung.com/java-initialize-hashset)
 - [Guide to EnumSet](https://www.baeldung.com/java-enumset)
 - [Set Operations in Java](https://www.baeldung.com/java-set-operations)
+- [Copying Sets in Java](https://www.baeldung.com/java-copy-sets)

core-java-modules/core-java-collections-set/pom.xml

@@ -14,20 +14,31 @@
     </parent>
 
     <dependencies>
-    <dependency>
-        <groupId>com.google.guava</groupId>
-        <artifactId>guava</artifactId>
-        <version>${guava.version}</version>
-    </dependency>
-    <dependency>
-        <groupId>org.apache.commons</groupId>
-        <artifactId>commons-collections4</artifactId>
-        <version>${commons-collections4.version}</version>
-    </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>${gson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-lang</groupId>
+            <artifactId>commons-lang</artifactId>
+            <version>${commons-lang.version}</version>
+        </dependency>
     </dependencies>
 
     <properties>
         <commons-collections4.version>4.3</commons-collections4.version>
         <guava.version>27.1-jre</guava.version>
+        <gson.version>2.8.5</gson.version>
     </properties>
-</project>
+</project>

core-java-modules/core-java-collections-set/src/main/java/com/baeldung/set/CopySets.java

@@ -0,0 +1,59 @@
+package com.baeldung.set;
+
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.apache.commons.lang.SerializationUtils;
+
+import com.google.gson.Gson;
+
+public class CopySets {
+
+    // Copy Constructor
+    public static <T> Set<T> copyByConstructor(Set<T> original) {
+        Set<T> copy = new HashSet<>(original);
+        return copy;
+    }
+
+    // Set.addAll
+    public static <T> Set<T> copyBySetAddAll(Set<T> original) {
+        Set<T> copy = new HashSet<>();
+        copy.addAll(original);
+        return copy;
+    }
+
+    // Set.clone
+    public static <T> Set<T> copyBySetClone(HashSet<T> original) {
+        Set<T> copy = (Set<T>) original.clone();
+        return copy;
+    }
+
+    // JSON
+    public static <T> Set<T> copyByJson(Set<T> original) {
+        Gson gson = new Gson();
+        String jsonStr = gson.toJson(original);
+        Set<T> copy = gson.fromJson(jsonStr, Set.class);
+
+        return copy;
+    }
+
+    // Apache Commons Lang
+    public static <T extends Serializable> Set<T> copyByApacheCommonsLang(Set<T> original) {
+        Set<T> copy = new HashSet<>();
+        for (T item : original) {
+            copy.add((T) SerializationUtils.clone(item));
+        }
+        return copy;
+    }
+
+    // Collectors.toSet
+    public static <T extends Serializable> Set<T> copyByCollectorsToSet(Set<T> original) {
+        Set<T> copy = original.stream()
+            .collect(Collectors.toSet());
+
+        return copy;
+    }
+
+}

core-java-modules/core-java-concurrency-advanced/pom.xml

@@ -72,7 +72,6 @@
     <properties>
         <!-- util -->
         <guava.version>21.0</guava.version>
-        <commons-lang3.version>3.5</commons-lang3.version>
         <commons-math3.version>3.6.1</commons-math3.version>
         <commons-collections4.version>4.1</commons-collections4.version>
         <collections-generic.version>4.01</collections-generic.version>

core-java-modules/core-java-concurrency-basic/README.md

@@ -17,3 +17,4 @@
 - [Runnable vs. Callable in Java](http://www.baeldung.com/java-runnable-callable)
 - [What is Thread-Safety and How to Achieve it?](https://www.baeldung.com/java-thread-safety)
 - [How to Start a Thread in Java](https://www.baeldung.com/java-start-thread)
+- [How to Delay Code Execution in Java](https://www.baeldung.com/java-delay-code-execution)

core-java-modules/core-java-concurrency-basic/pom.xml

@@ -45,8 +45,6 @@
     </build>
 
     <properties>
-        <!-- util -->
-        <commons-lang3.version>3.5</commons-lang3.version>
         <!-- testing -->
         <assertj.version>3.6.1</assertj.version>
         <avaitility.version>1.7.0</avaitility.version>

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/delay/Delay.java

@@ -1,4 +1,4 @@
-package com.baeldung.delay;
+package com.baeldung.concurrent.delay;
 
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -61,6 +61,7 @@ public class Delay {
 
         executorService.schedule(Delay::someTask1, delayInSeconds, TimeUnit.SECONDS);
 
+        executorService.shutdown();
     }
 
     private static void fixedRateServiceTask(Integer delayInSeconds) {
@@ -78,6 +79,7 @@ public class Delay {
 
         sf.cancel(true);
 
+        executorService.shutdown();
     }
 
     private static void someTask1() {

core-java-modules/core-java-concurrency-collections/pom.xml

@@ -62,7 +62,6 @@
     <properties>
         <!-- util -->
         <guava.version>21.0</guava.version>
-        <commons-lang3.version>3.5</commons-lang3.version>
         <commons-math3.version>3.6.1</commons-math3.version>
         <commons-collections4.version>4.1</commons-collections4.version>
         <collections-generic.version>4.01</collections-generic.version>

core-java-modules/core-java-exceptions/README.md

@@ -0,0 +1,3 @@
+## Relevant Articles:
+
+- [Will an Error Be Caught by Catch Block in Java?](https://www.baeldung.com/java-error-catch)

core-java-modules/core-java-exceptions/pom.xml

@@ -1,26 +1,35 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>com.baeldung.exception.numberformat</groupId>
-    <artifactId>core-java-exceptions</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
-    <name>core-java-exceptions</name>
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>com.baeldung.exception.numberformat</groupId>
+	<artifactId>core-java-exceptions</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<name>core-java-exceptions</name>
 
-    <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
-        <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-java</relativePath>
-    </parent>
+	<parent>
+		<groupId>com.baeldung</groupId>
+		<artifactId>parent-java</artifactId>
+		<version>0.0.1-SNAPSHOT</version>
+		<relativePath>../../parent-java</relativePath>
+	</parent>
 
-    <dependencies>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.12</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>${junit.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.commons</groupId>
+			<artifactId>commons-lang3</artifactId>
+			<version>${commons-lang3.version}</version>
+		</dependency>
+	</dependencies>
+
+	<properties>
+		<commons-lang3.version>3.9</commons-lang3.version>
+	</properties>
 
 </project>

core-java-modules/core-java-exceptions/src/test/java/com/baeldung/exception/error/ErrorGeneratorUnitTest.java

@@ -1,7 +1,6 @@
-package com.baeldung.error;
+package com.baeldung.exception.error;
 
 import org.junit.Assert;
-import org.junit.Before;
 import org.junit.Test;
 
 public class ErrorGeneratorUnitTest {

core-java-modules/core-java-io/pom.xml

@@ -248,7 +248,6 @@
     <properties>
 
         <!-- util -->
-        <commons-lang3.version>3.5</commons-lang3.version>
         <bouncycastle.version>1.55</bouncycastle.version>
         <commons-codec.version>1.10</commons-codec.version>
         <commons-math3.version>3.6.1</commons-math3.version>

core-java-modules/core-java-io/src/main/java/com/baeldung/files/Main.java

@@ -0,0 +1,24 @@
+package com.baeldung.files;
+
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingApacheCommonsIO;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingBufferedReader;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingGoogleGuava;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingLineNumberReader;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingNIOFileChannel;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingNIOFiles;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingScanner;
+
+public class Main {
+
+    private static final String INPUT_FILE_NAME = "src/main/resources/input.txt";
+
+    public static void main(String... args) throws Exception {
+        System.out.printf("Total Number of Lines Using BufferedReader: %s%n", getTotalNumberOfLinesUsingBufferedReader(INPUT_FILE_NAME));
+        System.out.printf("Total Number of Lines Using LineNumberReader: %s%n", getTotalNumberOfLinesUsingLineNumberReader(INPUT_FILE_NAME));
+        System.out.printf("Total Number of Lines Using Scanner: %s%n", getTotalNumberOfLinesUsingScanner(INPUT_FILE_NAME));
+        System.out.printf("Total Number of Lines Using NIO Files: %s%n", getTotalNumberOfLinesUsingNIOFiles(INPUT_FILE_NAME));
+        System.out.printf("Total Number of Lines Using NIO FileChannel: %s%n", getTotalNumberOfLinesUsingNIOFileChannel(INPUT_FILE_NAME));
+        System.out.printf("Total Number of Lines Using Apache Commons IO: %s%n", getTotalNumberOfLinesUsingApacheCommonsIO(INPUT_FILE_NAME));
+        System.out.printf("Total Number of Lines Using NIO Google Guava: %s%n", getTotalNumberOfLinesUsingGoogleGuava(INPUT_FILE_NAME));
+    }
+}

core-java-modules/core-java-io/src/main/java/com/baeldung/files/NumberOfLineFinder.java

@@ -0,0 +1,112 @@
+package com.baeldung.files;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.LineNumberReader;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileChannel.MapMode;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Stream;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.LineIterator;
+
+public class NumberOfLineFinder {
+
+    public static int getTotalNumberOfLinesUsingBufferedReader(String fileName) {
+        int lines = 0;
+        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
+            while (reader.readLine() != null) {
+                lines++;
+            }
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        return lines;
+    }
+
+    public static int getTotalNumberOfLinesUsingLineNumberReader(String fileName) {
+        int lines = 0;
+        try (LineNumberReader reader = new LineNumberReader(new FileReader(fileName))) {
+            reader.skip(Integer.MAX_VALUE);
+            lines = reader.getLineNumber() + 1;
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        return lines;
+    }
+
+    public static int getTotalNumberOfLinesUsingScanner(String fileName) {
+        int lines = 0;
+        try (Scanner scanner = new Scanner(new FileReader(fileName))) {
+            while (scanner.hasNextLine()) {
+                scanner.nextLine();
+                lines++;
+            }
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        return lines;
+    }
+
+    public static int getTotalNumberOfLinesUsingNIOFiles(String fileName) {
+        int lines = 0;
+        try (Stream<String> fileStream = Files.lines(Paths.get(fileName))) {
+            lines = (int) fileStream.count();
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        return lines;
+    }
+
+    public static int getTotalNumberOfLinesUsingNIOFileChannel(String fileName) {
+        int lines = 1;
+        try (FileChannel channel = FileChannel.open(Paths.get(fileName), StandardOpenOption.READ)) {
+            ByteBuffer byteBuffer = channel.map(MapMode.READ_ONLY, 0, channel.size());
+            while (byteBuffer.hasRemaining()) {
+                byte currentChar = byteBuffer.get();
+                if (currentChar == '\n') {
+                    lines++;
+                }
+            }
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        return lines;
+    }
+
+    public static int getTotalNumberOfLinesUsingApacheCommonsIO(String fileName) {
+        int lines = 0;
+        try {
+            LineIterator lineIterator = FileUtils.lineIterator(new File(fileName));
+            while (lineIterator.hasNext()) {
+                lineIterator.nextLine();
+                lines++;
+            }
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        return lines;
+    }
+
+    public static int getTotalNumberOfLinesUsingGoogleGuava(String fileName) {
+        int lines = 0;
+        try {
+            List<String> lineItems = com.google.common.io.Files.readLines(Paths.get(fileName)
+                .toFile(), Charset.defaultCharset());
+            lines = lineItems.size();
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        return lines;
+    }
+
+}

core-java-modules/core-java-io/src/test/java/com/baeldung/file/NumberOfLineFinderUnitTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.file;
+
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingApacheCommonsIO;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingBufferedReader;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingGoogleGuava;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingLineNumberReader;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingNIOFileChannel;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingNIOFiles;
+import static com.baeldung.files.NumberOfLineFinder.getTotalNumberOfLinesUsingScanner;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class NumberOfLineFinderUnitTest {
+    private static final String INPUT_FILE_NAME = "src/main/resources/input.txt";
+    private static final int ACTUAL_LINE_COUNT = 45;
+
+    @Test
+    public void whenUsingBufferedReader_thenReturnTotalNumberOfLines() {
+        int lines = getTotalNumberOfLinesUsingBufferedReader(INPUT_FILE_NAME);
+        assertEquals(ACTUAL_LINE_COUNT, lines);
+    }
+
+    @Test
+    public void whenUsingLineNumberReader_thenReturnTotalNumberOfLines() {
+        int lines = getTotalNumberOfLinesUsingLineNumberReader(INPUT_FILE_NAME);
+        assertEquals(ACTUAL_LINE_COUNT, lines);
+    }
+
+    @Test
+    public void whenUsingScanner_thenReturnTotalNumberOfLines() {
+        int lines = getTotalNumberOfLinesUsingScanner(INPUT_FILE_NAME);
+        assertEquals(ACTUAL_LINE_COUNT, lines);
+    }
+
+    @Test
+    public void whenUsingNIOFiles_thenReturnTotalNumberOfLines() {
+        int lines = getTotalNumberOfLinesUsingNIOFiles(INPUT_FILE_NAME);
+        assertEquals(ACTUAL_LINE_COUNT, lines);
+    }
+
+    @Test
+    public void whenUsingNIOFileChannel_thenReturnTotalNumberOfLines() {
+        int lines = getTotalNumberOfLinesUsingNIOFileChannel(INPUT_FILE_NAME);
+        assertEquals(ACTUAL_LINE_COUNT, lines);
+    }
+
+    @Test
+    public void whenUsingApacheCommonsIO_thenReturnTotalNumberOfLines() {
+        int lines = getTotalNumberOfLinesUsingApacheCommonsIO(INPUT_FILE_NAME);
+        assertEquals(ACTUAL_LINE_COUNT, lines);
+    }
+
+    @Test
+    public void whenUsingGoogleGuava_thenReturnTotalNumberOfLines() {
+        int lines = getTotalNumberOfLinesUsingGoogleGuava(INPUT_FILE_NAME);
+        assertEquals(ACTUAL_LINE_COUNT, lines);
+    }
+
+}

core-java-modules/core-java-jpms/decoupling-pattern1/consumermodule/pom.xml

@@ -11,6 +11,14 @@
         <version>1.0</version>
     </parent>
     
+    <dependencies>
+        <dependency>
+            <groupId>com.baeldung.servicemodule</groupId>
+            <artifactId>servicemodule</artifactId>
+            <version>1.0</version>           
+        </dependency>
+    </dependencies>
+    
     <build>
         <plugins>
             <plugin>
@@ -19,12 +27,4 @@
             </plugin>
         </plugins>
     </build>
-    
-    <dependencies>
-        <dependency>
-            <groupId>com.baeldung.servicemodule</groupId>
-            <artifactId>servicemodule</artifactId>
-            <version>1.0</version>           
-        </dependency>
-    </dependencies>
 </project>

core-java-modules/core-java-jpms/decoupling-pattern2/consumermodule/pom.xml

@@ -2,17 +2,18 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>com.baeldung.decoupling-pattern2</artifactId>
-        <groupId>decoupling-pattern2</groupId>
-        <version>1.0-SNAPSHOT</version>
-    </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>com.baeldung.consumermodule</groupId>
     <artifactId>consumermodule</artifactId>
     <version>1.0</version>
 
+    <parent>
+        <artifactId>com.baeldung.decoupling-pattern2</artifactId>
+        <groupId>decoupling-pattern2</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+
     <dependencies>
         <dependency>
             <groupId>com.baeldung.servicemodule</groupId>

core-java-modules/core-java-jvm/pom.xml

@@ -35,7 +35,6 @@
     </dependencies>
 
     <properties>
-        <commons-lang3.version>3.5</commons-lang3.version>
         <assertj.version>3.6.1</assertj.version>
     </properties>
 </project>

core-java-modules/core-java-lambdas/README.MD

@@ -1,3 +0,0 @@
-### Relevant Articles
-
-- [Why Do Local Variables Used in Lambdas Have to Be Final or Effectively Final?](https://www.baeldung.com/java-lambda-effectively-final-local-variables)