Merge pull request #2 from eugenp/master

Merge latest PRs

.gitignore

@@ -65,6 +65,7 @@ core-java-io/target_link.txt
 core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
 ethereum/logs/
 jmeter/src/main/resources/*-JMeter.csv
+ninja/devDb.mv.db
 
 **/node_modules/
 **/dist

akka-http/src/test/java/com/baeldung/akkahttp/UserServerUnitTest.java

@@ -31,10 +31,10 @@ public class UserServerUnitTest extends JUnitRouteTest {
             .assertStatusCode(404);
 
     appRoute.run(HttpRequest.DELETE("/users/1"))
-            .assertStatusCode(200);
+            .assertStatusCode(405);
 
     appRoute.run(HttpRequest.DELETE("/users/42"))
-            .assertStatusCode(200);
+            .assertStatusCode(405);
 
     appRoute.run(HttpRequest.POST("/users")
             .withEntity(HttpEntities.create(ContentTypes.APPLICATION_JSON, zaphod())))

algorithms-miscellaneous-2/README.md

@@ -13,4 +13,5 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Create a Sudoku Solver in Java](https://www.baeldung.com/java-sudoku)
 - [Displaying Money Amounts in Words](https://www.baeldung.com/java-money-into-words)
 - [A Collaborative Filtering Recommendation System in Java](https://www.baeldung.com/java-collaborative-filtering-recommendations)
+- [Implementing A* Pathfinding in Java](https://www.baeldung.com/java-a-star-pathfinding)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-1) [[next -->]](/../algorithms-miscellaneous-3)

algorithms-miscellaneous-5/README.md

@@ -12,4 +12,12 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [How to Determine if a Binary Tree is Balanced](https://www.baeldung.com/java-balanced-binary-tree)
 - [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
 - [Overview of Combinatorial Problems in Java](https://www.baeldung.com/java-combinatorial-algorithms)
+- [Prim’s Algorithm](https://www.baeldung.com/java-prim-algorithm)
+- [Maximum Subarray Problem](https://www.baeldung.com/java-maximum-subarray)
+- [How to Merge Two Sorted Arrays](https://www.baeldung.com/java-merge-sorted-arrays)
+- [Median of Stream of Integers using Heap](https://www.baeldung.com/java-stream-integers-median-using-heap)
+- [Kruskal’s Algorithm for Spanning Trees](https://www.baeldung.com/java-spanning-trees-kruskal)
+- [Balanced Brackets Algorithm in Java](https://www.baeldung.com/java-balanced-brackets-algorithm)
+- [Efficiently Merge Sorted Java Sequences](https://www.baeldung.com/java-merge-sorted-sequences)
+- [Introduction to Greedy Algorithms with Java](https://www.baeldung.com/java-greedy-algorithms)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-4)

algorithms-miscellaneous-5/pom.xml

@@ -39,6 +39,16 @@
             <artifactId>guava</artifactId>
             <version>${guava.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-commons</artifactId>
+            <version>${junit.platform.version}</version>
+        </dependency>
 
         <dependency>
             <groupId>org.assertj</groupId>
@@ -66,6 +76,8 @@
         <commons-codec.version>1.11</commons-codec.version>
         <commons-math3.version>3.6.1</commons-math3.version>
         <guava.version>28.1-jre</guava.version>
+        <jackson.version>2.10.2</jackson.version>
+        <junit.platform.version>1.6.0</junit.platform.version>
     </properties>
 
 </project>

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/balancedbinarytree/AVLTree.java

@@ -0,0 +1,141 @@
+package com.baeldung.algorithms.balancedbinarytree;
+
+public class AVLTree {
+
+    public class Node {
+        int key;
+        int height;
+        Node left;
+        Node right;
+
+        Node(int key) {
+            this.key = key;
+        }
+    }
+
+    private Node root;
+
+    public Node find(int key) {
+        Node current = root;
+        while (current != null) {
+            if (current.key == key) {
+               break;
+            }
+            current = current.key < key ? current.right : current.left;
+        }
+        return current;
+    }
+
+    public void insert(int key) {
+        root = insert(root, key);
+    }
+
+    public void delete(int key) {
+        root = delete(root, key);
+    }
+
+    public Node getRoot() {
+        return root;
+    }
+
+    public int height() {
+        return root == null ? -1 : root.height;
+    }
+
+    private Node insert(Node node, int key) {
+        if (node == null) {
+            return new Node(key);
+        } else if (node.key > key) {
+            node.left = insert(node.left, key);
+        } else if (node.key < key) {
+            node.right = insert(node.right, key);
+        } else {
+            throw new RuntimeException("duplicate Key!");
+        }
+        return rebalance(node);
+    }
+
+    private Node delete(Node node, int key) {
+        if (node == null) {
+            return node;
+        } else if (node.key > key) {
+            node.left = delete(node.left, key);
+        } else if (node.key < key) {
+            node.right = delete(node.right, key);
+        } else {
+            if (node.left == null || node.right == null) {
+                node = (node.left == null) ? node.right : node.left;
+            } else {
+                Node mostLeftChild = mostLeftChild(node.right);
+                node.key = mostLeftChild.key;
+                node.right = delete(node.right, node.key);
+            }
+        }
+        if (node != null) {
+            node = rebalance(node);
+        }
+        return node;
+    }
+
+    private Node mostLeftChild(Node node) {
+        Node current = node;
+        /* loop down to find the leftmost leaf */
+        while (current.left != null) {
+            current = current.left;
+        }
+        return current;
+    }
+
+    private Node rebalance(Node z) {
+        updateHeight(z);
+        int balance = getBalance(z);
+        if (balance > 1) {
+            if (height(z.right.right) > height(z.right.left)) {
+                z = rotateLeft(z);
+            } else {
+                z.right = rotateRight(z.right);
+                z = rotateLeft(z);
+            }
+        } else if (balance < -1) {
+            if (height(z.left.left) > height(z.left.right)) {
+                z = rotateRight(z);
+            } else {
+                z.left = rotateLeft(z.left);
+                z = rotateRight(z);
+            }
+        }
+        return z;
+    }
+
+    private Node rotateRight(Node y) {
+        Node x = y.left;
+        Node z = x.right;
+        x.right = y;
+        y.left = z;
+        updateHeight(y);
+        updateHeight(x);
+        return x;
+    }
+
+    private Node rotateLeft(Node y) {
+        Node x = y.right;
+        Node z = x.left;
+        x.left = y;
+        y.right = z;
+        updateHeight(y);
+        updateHeight(x);
+        return x;
+    }
+
+    private void updateHeight(Node n) {
+        n.height = 1 + Math.max(height(n.left), height(n.right));
+    }
+
+    private int height(Node n) {
+        return n == null ? -1 : n.height;
+    }
+
+    public int getBalance(Node n) {
+        return (n == null) ? 0 : height(n.right) - height(n.left);
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/BoruvkaMST.java

@@ -0,0 +1,61 @@
+package com.baeldung.algorithms.boruvka;
+
+public class BoruvkaMST {
+
+    private static Tree mst = new Tree();
+    private static int totalWeight;
+
+    public BoruvkaMST(Graph graph) {
+        DisjointSet dSet = new DisjointSet(graph.getNodes());
+
+        // repeat at most log N times or until we have N-1 edges
+        for (int t = 1; t < graph.getNodes() && mst.getEdgeCount() < graph.getNodes() - 1; t = t + t) {
+
+            // foreach tree in forest, find closest edge
+            Edge[] closestEdgeArray = new Edge[graph.getNodes()];
+            for (Edge edge : graph.getAllEdges()) {
+                int first = edge.getFirst();
+                int second = edge.getSecond();
+                int firstParent = dSet.getParent(first);
+                int secondParent = dSet.getParent(second);
+                if (firstParent == secondParent) {
+                    continue; // same tree
+                }
+                if (closestEdgeArray[firstParent] == null || edge.getWeight() < closestEdgeArray[firstParent].getWeight()) {
+                    closestEdgeArray[firstParent] = edge;
+                }
+                if (closestEdgeArray[secondParent] == null || edge.getWeight() < closestEdgeArray[secondParent].getWeight()) {
+                    closestEdgeArray[secondParent] = edge;
+                }
+            }
+
+            // add newly discovered edges to MST
+            for (int i = 0; i < graph.getNodes(); i++) {
+                Edge edge = closestEdgeArray[i];
+                if (edge != null) {
+                    int first = edge.getFirst();
+                    int second = edge.getSecond();
+                    // don't add the same edge twice
+                    if (dSet.getParent(first) != dSet.getParent(second)) {
+                        mst.addEdge(edge);
+                        totalWeight += edge.getWeight();
+                        dSet.union(first, second);
+                    }
+                }
+            }
+        }
+    }
+
+    public Iterable<Edge> getMST() {
+        return mst;
+    }
+
+    public int getTotalWeight() {
+        return totalWeight;
+    }
+
+    public String toString() {
+        return "MST: " + mst.toString() + " | Total Weight: " + totalWeight;
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/DisjointSet.java

@@ -0,0 +1,49 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.Arrays;
+
+public class DisjointSet {
+
+    private int[] nodeParents;
+    private int[] nodeRanks;
+
+    public DisjointSet(int n) {
+        nodeParents = new int[n];
+        nodeRanks = new int[n];
+        for (int i = 0; i < n; i++) {
+            nodeParents[i] = i;
+            nodeRanks[i] = 0;
+        }
+    }
+
+    public int getParent(int node) {
+        while (node != nodeParents[node]) {
+            node = nodeParents[node];
+        }
+        return node;
+    }
+
+    public void union(int node1, int node2) {
+        int node1Parent = getParent(node1);
+        int node2Parent = getParent(node2);
+        if (node1Parent == node2Parent) {
+            return;
+        }
+
+        if (nodeRanks[node1Parent] < nodeRanks[node2Parent]) {
+            nodeParents[node1Parent] = node2Parent;
+        }
+        else if (nodeRanks[node1Parent] > nodeRanks[node2Parent]) {
+            nodeParents[node2Parent] = node1Parent;
+        }
+        else {
+            nodeParents[node2Parent] = node1Parent;
+            nodeRanks[node1Parent]++;
+        }
+    }
+
+    public String toString() {
+        return "Parent: " + Arrays.toString(nodeParents) + "Rank: " + Arrays.toString(nodeRanks);
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/Edge.java

@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.boruvka;
+
+public class Edge {
+
+    private final int first;
+    private final int second;
+    private final int weight;
+
+    public Edge(int first, int second, int weight) {
+        this.first = first;
+        this.second = second;
+        this.weight = weight;
+    }
+
+    public double getWeight() {
+        return weight;
+    }
+
+    public int getFirst() {
+        return first;
+    }
+    
+    public int getSecond() {
+        return second;
+    }
+
+    public int getOtherNode(int firstNode) {
+        int secondNode = 0;
+        if (firstNode == first)
+            secondNode = second;
+        else if (firstNode == second)
+            secondNode = first;
+        return secondNode;
+    }
+
+    public String toString() {
+        return String.format("%d-%d %d", first, second, weight);
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/Graph.java

@@ -0,0 +1,64 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.io.IOException;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+public class Graph {
+
+    private int nodes;
+    private int edges;
+    private Tree[] trees;
+
+    public Graph(Input jsonGraph) throws JsonParseException, JsonMappingException, IOException {
+        nodes = jsonGraph.getNodes();
+        trees = (Tree[]) new Tree[nodes];
+        for (int i = 0; i < nodes; i++) {
+            trees[i] = new Tree();
+        }
+
+        int edgesFromInput = jsonGraph.getEdges();
+        for (int i = 0; i < edgesFromInput; i++) {
+            int first = jsonGraph.getEdgeList()
+                .get(i)
+                .getFirst();
+            int second = jsonGraph.getEdgeList()
+                .get(i)
+                .getSecond();
+            int weight = jsonGraph.getEdgeList()
+                .get(i)
+                .getWeight();
+            Edge edge = new Edge(first, second, weight);
+            
+            trees[first].addEdge(edge);
+            trees[second].addEdge(edge);
+            edges++;
+        }
+
+    }
+
+    public int getNodes() {
+        return nodes;
+    }
+
+    public int getEdges() {
+        return edges;
+    }
+
+    public Iterable<Edge> iterableTree(int i) {
+        return trees[i];
+    }
+
+    public Iterable<Edge> getAllEdges() {
+        Iterable<Edge> list = new Tree();
+        for (int i = 0; i < nodes; i++) {
+            for (Edge edge : iterableTree(i)) {
+                if (edge.getOtherNode(i) > i) {
+                    ((Tree) list).addEdge(edge);
+                }
+            }
+        }
+        return list;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/Input.java

@@ -0,0 +1,65 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.List;
+
+public class Input {
+    private int nodes;
+    private int edges;
+    private List<E> edgeList;
+
+    public int getNodes() {
+        return nodes;
+    }
+
+    public void setNodes(int nodes) {
+        this.nodes = nodes;
+    }
+
+    public int getEdges() {
+        return edges;
+    }
+
+    public void setEdges(int edges) {
+        this.edges = edges;
+    }
+
+    public List<E> getEdgeList() {
+        return edgeList;
+    }
+
+    public void setEdgeList(List<E> edgeList) {
+        this.edgeList = edgeList;
+    }
+
+    static class E {
+        private int first;
+        private int second;
+        private int weight;
+
+        public int getFirst() {
+            return first;
+        }
+
+        public void setFirst(int first) {
+            this.first = first;
+        }
+
+        public int getSecond() {
+            return second;
+        }
+
+        public void setSecond(int second) {
+            this.second = second;
+        }
+
+        public int getWeight() {
+            return weight;
+        }
+
+        public void setWeight(int weight) {
+            this.weight = weight;
+        }
+
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/boruvka/Tree.java

@@ -0,0 +1,63 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.Iterator;
+
+public class Tree implements Iterable<Edge> {
+    private Node root;
+    private int edgeCount;
+
+    private static class Node {
+        private Edge edge;
+        private Node next;
+
+        public String toString() {
+            String nextStr = next != null ? next.toString() : "";
+            return edge.toString() + " | " + nextStr;
+        }
+    }
+
+    public Tree() {
+        root = null;
+        edgeCount = 0;
+    }
+
+    public int getEdgeCount() {
+        return edgeCount;
+    }
+
+    public void addEdge(Edge edge) {
+        Node oldRoot = root;
+        root = new Node();
+        root.edge = edge;
+        root.next = oldRoot;
+        edgeCount++;
+    }
+
+    public String toString() {
+        String rootStr = root != null ? root.toString() : "";
+        return "Tree: " + rootStr + "Size: " + edgeCount;
+    }
+
+    public Iterator<Edge> iterator() {
+        return new LinkedIterator(root);
+    }
+
+    private class LinkedIterator implements Iterator<Edge> {
+        private Node current;
+
+        public LinkedIterator(Node root) {
+            current = root;
+        }
+
+        public boolean hasNext() {
+            return current != null;
+        }
+
+        public Edge next() {
+            Edge edge = current.edge;
+            current = current.next;
+            return edge;
+        }
+    }
+
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/balancedbinarytree/AVLTreeUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.algorithms.balancedbinarytree;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class AVLTreeUnitTest {
+
+    @Test
+    public void givenEmptyTree_whenHeightCalled_shouldReturnMinus1() {
+        AVLTree tree = new AVLTree();
+        Assert.assertEquals(-1, tree.height());
+    }
+
+    @Test
+    public void givenEmptyTree_whenInsertCalled_heightShouldBeZero() {
+        AVLTree tree = new AVLTree();
+        tree.insert(1);
+        Assert.assertEquals(0, tree.height());
+    }
+
+    @Test
+    public void givenEmptyTree_whenInsertCalled_treeShouldBeAvl() {
+        AVLTree tree = new AVLTree();
+        tree.insert(1);
+        Assert.assertTrue(isAVL(tree));
+    }
+
+    @Test
+    public void givenSampleTree_whenInsertCalled_treeShouldBeAvl() {
+        AVLTree tree = getSampleAVLTree();
+        int newKey = 11;
+        tree.insert(newKey);
+        Assert.assertTrue(isAVL(tree));
+    }
+
+    @Test
+    public void givenSampleTree_whenFindExistingKeyCalled_shouldReturnMatchedNode() {
+        AVLTree tree = getSampleAVLTree();
+        int existingKey = 2;
+        AVLTree.Node result = tree.find(existingKey);
+        Assert.assertEquals(result.key, existingKey);
+    }
+
+    @Test
+    public void givenSampleTree_whenFindNotExistingKeyCalled_shouldReturnNull() {
+        AVLTree tree = getSampleAVLTree();
+        int notExistingKey = 11;
+        AVLTree.Node result = tree.find(notExistingKey);
+        Assert.assertNull(result);
+    }
+
+    @Test
+    public void givenEmptyTree_whenDeleteCalled_treeShouldBeAvl() {
+        AVLTree tree = new AVLTree();
+        tree.delete(1);
+        Assert.assertTrue(isAVL(tree));
+    }
+
+    @Test
+    public void givenSampleTree_whenDeleteCalled_treeShouldBeAvl() {
+        AVLTree tree = getSampleAVLTree();
+        tree.delete(1);
+        Assert.assertTrue(isAVL(tree, tree.getRoot()));
+    }
+
+    private boolean isAVL(AVLTree tree) {
+       return isAVL(tree, tree.getRoot());
+    }
+
+    private boolean isAVL(AVLTree tree, AVLTree.Node node) {
+        if ( node == null )
+            return true;
+        int balance = tree.getBalance(node);
+        return (balance <= 1 && balance >= -1) && isAVL(tree, node.left) && isAVL(tree, node.right);
+    }
+
+    private AVLTree getSampleAVLTree() {
+        AVLTree avlTree = new AVLTree();
+        for (int i = 0; i < 10; i++)
+            avlTree.insert(i);
+        return avlTree;
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/boruvka/BoruvkaUnitTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.algorithms.boruvka;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class BoruvkaUnitTest {
+
+    private Input input;
+    private static String INPUT_JSON = "/input.json";
+
+    @Before
+    public void convertInputJsonToObject() throws JsonParseException, JsonMappingException, IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        StringBuilder jsonStr = new StringBuilder();
+        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(BoruvkaMST.class.getResourceAsStream(INPUT_JSON)))) {
+            String line;
+            while ((line = bufferedReader.readLine()) != null) {
+                jsonStr.append(line)
+                    .append("\n");
+            }
+        }
+
+        input = mapper.readValue(jsonStr.toString(), Input.class);
+
+    }
+
+    @Test
+    public void givenInputGraph_whenBoruvkaPerformed_thenMinimumSpanningTree() throws JsonParseException, JsonMappingException, IOException {
+        Graph graph = new Graph(input);
+        BoruvkaMST boruvkaMST = new BoruvkaMST(graph);
+
+        Tree mst = (Tree) boruvkaMST.getMST();
+
+        assertEquals(30, boruvkaMST.getTotalWeight());
+        assertEquals(4, mst.getEdgeCount());
+    }
+
+}

algorithms-miscellaneous-5/src/test/resources/input.json

@@ -0,0 +1,41 @@
+{
+	"nodes": 5,
+	"edges": 7,
+	"edgeList": [
+		{
+			"first": 0,
+			"second": 1,
+			"weight": 8
+		},
+		{
+			"first": 0,
+			"second": 2,
+			"weight": 5
+		},
+		{
+			"first": 1,
+			"second": 2,
+			"weight": 9
+		},
+		{
+			"first": 1,
+			"second": 3,
+			"weight": 11
+		},
+		{
+			"first": 2,
+			"second": 3,
+			"weight": 15
+		},
+		{
+			"first": 2,
+			"second": 4,
+			"weight": 10
+		},
+		{
+			"first": 3,
+			"second": 4,
+			"weight": 7
+		}
+	]
+}

algorithms-searching/src/main/java/com/baeldung/algorithms/suffixtree/Node.java

@@ -0,0 +1,57 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Node {
+    private String text;
+    private List<Node> children;
+    private int position;
+
+    public Node(String word, int position) {
+        this.text = word;
+        this.position = position;
+        this.children = new ArrayList<>();
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public void setPosition(int position) {
+        this.position = position;
+    }
+
+    public List<Node> getChildren() {
+        return children;
+    }
+
+    public void setChildren(List<Node> children) {
+        this.children = children;
+    }
+
+    public String printTree(String depthIndicator) {
+        String str = "";
+        String positionStr = position > -1 ? "[" + String.valueOf(position) + "]" : "";
+        str += depthIndicator + text + positionStr + "\n";
+
+        for (int i = 0; i < children.size(); i++) {
+            str += children.get(i)
+                .printTree(depthIndicator + "\t");
+        }
+        return str;
+    }
+
+    @Override
+    public String toString() {
+        return printTree("");
+    }
+}

algorithms-searching/src/main/java/com/baeldung/algorithms/suffixtree/SuffixTree.java

@@ -0,0 +1,175 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SuffixTree {
+    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTree.class);
+    private static final String WORD_TERMINATION = "$";
+    private static final int POSITION_UNDEFINED = -1;
+    private Node root;
+    private String fullText;
+
+    public SuffixTree(String text) {
+        root = new Node("", POSITION_UNDEFINED);
+        for (int i = 0; i < text.length(); i++) {
+            addSuffix(text.substring(i) + WORD_TERMINATION, i);
+        }
+        fullText = text;
+    }
+
+    public List<String> searchText(String pattern) {
+        LOGGER.info("Searching for pattern \"{}\"", pattern);
+        List<String> result = new ArrayList<>();
+        List<Node> nodes = getAllNodesInTraversePath(pattern, root, false);
+
+        if (nodes.size() > 0) {
+            Node lastNode = nodes.get(nodes.size() - 1);
+            if (lastNode != null) {
+                List<Integer> positions = getPositions(lastNode);
+                positions = positions.stream()
+                    .sorted()
+                    .collect(Collectors.toList());
+                positions.forEach(m -> result.add((markPatternInText(m, pattern))));
+            }
+        }
+        return result;
+    }
+
+    private void addSuffix(String suffix, int position) {
+        LOGGER.info(">>>>>>>>>>>> Adding new suffix {}", suffix);
+        List<Node> nodes = getAllNodesInTraversePath(suffix, root, true);
+        if (nodes.size() == 0) {
+            addChildNode(root, suffix, position);
+            LOGGER.info("{}", printTree());
+        } else {
+            Node lastNode = nodes.remove(nodes.size() - 1);
+            String newText = suffix;
+            if (nodes.size() > 0) {
+                String existingSuffixUptoLastNode = nodes.stream()
+                    .map(a -> a.getText())
+                    .reduce("", String::concat);
+
+                // Remove prefix from newText already included in parent
+                newText = newText.substring(existingSuffixUptoLastNode.length());
+            }
+            extendNode(lastNode, newText, position);
+            LOGGER.info("{}", printTree());
+        }
+    }
+
+    private List<Integer> getPositions(Node node) {
+        List<Integer> positions = new ArrayList<>();
+        if (node.getText()
+            .endsWith(WORD_TERMINATION)) {
+            positions.add(node.getPosition());
+        }
+        for (int i = 0; i < node.getChildren()
+            .size(); i++) {
+            positions.addAll(getPositions(node.getChildren()
+                .get(i)));
+        }
+        return positions;
+    }
+
+    private String markPatternInText(Integer startPosition, String pattern) {
+        String matchingTextLHS = fullText.substring(0, startPosition);
+        String matchingText = fullText.substring(startPosition, startPosition + pattern.length());
+        String matchingTextRHS = fullText.substring(startPosition + pattern.length());
+        return matchingTextLHS + "[" + matchingText + "]" + matchingTextRHS;
+    }
+
+    private void addChildNode(Node parentNode, String text, int position) {
+        parentNode.getChildren()
+            .add(new Node(text, position));
+    }
+
+    private void extendNode(Node node, String newText, int position) {
+        String currentText = node.getText();
+        String commonPrefix = getLongestCommonPrefix(currentText, newText);
+
+        if (commonPrefix != currentText) {
+            String parentText = currentText.substring(0, commonPrefix.length());
+            String childText = currentText.substring(commonPrefix.length());
+            splitNodeToParentAndChild(node, parentText, childText);
+        }
+
+        String remainingText = newText.substring(commonPrefix.length());
+        addChildNode(node, remainingText, position);
+    }
+
+    private void splitNodeToParentAndChild(Node parentNode, String parentNewText, String childNewText) {
+        Node childNode = new Node(childNewText, parentNode.getPosition());
+
+        if (parentNode.getChildren()
+            .size() > 0) {
+            while (parentNode.getChildren()
+                .size() > 0) {
+                childNode.getChildren()
+                    .add(parentNode.getChildren()
+                        .remove(0));
+            }
+        }
+
+        parentNode.getChildren()
+            .add(childNode);
+        parentNode.setText(parentNewText);
+        parentNode.setPosition(POSITION_UNDEFINED);
+    }
+
+    private String getLongestCommonPrefix(String str1, String str2) {
+        int compareLength = Math.min(str1.length(), str2.length());
+        for (int i = 0; i < compareLength; i++) {
+            if (str1.charAt(i) != str2.charAt(i)) {
+                return str1.substring(0, i);
+            }
+        }
+        return str1.substring(0, compareLength);
+    }
+
+    private List<Node> getAllNodesInTraversePath(String pattern, Node startNode, boolean isAllowPartialMatch) {
+        List<Node> nodes = new ArrayList<>();
+        for (int i = 0; i < startNode.getChildren()
+            .size(); i++) {
+            Node currentNode = startNode.getChildren()
+                .get(i);
+            String nodeText = currentNode.getText();
+            if (pattern.charAt(0) == nodeText.charAt(0)) {
+                if (isAllowPartialMatch && pattern.length() <= nodeText.length()) {
+                    nodes.add(currentNode);
+                    return nodes;
+                }
+
+                int compareLength = Math.min(nodeText.length(), pattern.length());
+                for (int j = 1; j < compareLength; j++) {
+                    if (pattern.charAt(j) != nodeText.charAt(j)) {
+                        if (isAllowPartialMatch) {
+                            nodes.add(currentNode);
+                        }
+                        return nodes;
+                    }
+                }
+
+                nodes.add(currentNode);
+                if (pattern.length() > compareLength) {
+                    List<Node> nodes2 = getAllNodesInTraversePath(pattern.substring(compareLength), currentNode, isAllowPartialMatch);
+                    if (nodes2.size() > 0) {
+                        nodes.addAll(nodes2);
+                    } else if (!isAllowPartialMatch) {
+                        nodes.add(null);
+                    }
+                }
+                return nodes;
+            }
+        }
+        return nodes;
+    }
+
+    public String printTree() {
+        return root.printTree("");
+    }
+}

algorithms-searching/src/test/java/com/baeldung/algorithms/suffixtree/SuffixTreeUnitTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SuffixTreeUnitTest {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTreeUnitTest.class);
+
+    private static SuffixTree suffixTree;
+
+    @BeforeClass
+    public static void setUp() {
+        suffixTree = new SuffixTree("havanabanana");
+        printTree();
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForA_thenReturn6Matches() {
+        List<String> matches = suffixTree.searchText("a");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "h[a]vanabanana", "hav[a]nabanana", "havan[a]banana", "havanab[a]nana", "havanaban[a]na", "havanabanan[a]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNab_thenReturn1Match() {
+        List<String> matches = suffixTree.searchText("nab");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hava[nab]anana" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNag_thenReturnNoMatches() {
+        List<String> matches = suffixTree.searchText("nag");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] {}, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForBanana_thenReturn2Matches() {
+        List<String> matches = suffixTree.searchText("ana");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hav[ana]banana", "havanab[ana]na", "havanaban[ana]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNa_thenReturn4Matches() {
+        List<String> matches = suffixTree.searchText("na");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hava[na]banana", "havanaba[na]na", "havanabana[na]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForX_thenReturnNoMatches() {
+        List<String> matches = suffixTree.searchText("x");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] {}, matches.toArray());
+    }
+
+    private static void printTree() {
+        suffixTree.printTree();
+
+        LOGGER.info("\n" + suffixTree.printTree());
+        LOGGER.info("==============================================");
+    }
+}

algorithms-sorting-2/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [Partitioning and Sorting Arrays with Many Repeated Entries](https://www.baeldung.com/java-sorting-arrays-with-repeated-entries)

apache-beam/pom.xml

@@ -0,0 +1,43 @@
+<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>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <groupId>com.baeldung.apache</groupId>
+    <artifactId>apache-beam</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.beam</groupId>
+            <artifactId>beam-sdks-java-core</artifactId>
+            <version>${beam.version}</version>
+        </dependency>
+        <!-- runtime scoped -->
+        <dependency>
+            <groupId>org.apache.beam</groupId>
+            <artifactId>beam-runners-direct-java</artifactId>
+            <version>${beam.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <!-- test scoped -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <beam.version>2.19.0</beam.version>
+        <assertj.version>3.6.1</assertj.version>
+    </properties>
+
+</project>

apache-beam/src/main/java/com/baeldung/apache/beam/intro/WordCount.java

@@ -0,0 +1,71 @@
+package com.baeldung.apache.beam.intro;
+
+import java.util.Arrays;
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.io.TextIO;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Count;
+import org.apache.beam.sdk.transforms.Filter;
+import org.apache.beam.sdk.transforms.FlatMapElements;
+import org.apache.beam.sdk.transforms.MapElements;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.TypeDescriptors;
+
+public class WordCount {
+    
+    public static boolean wordCount(String inputFilePath, String outputFilePath) {
+        // We use default options
+        PipelineOptions options = PipelineOptionsFactory.create();
+        // to create the pipeline
+        Pipeline p = Pipeline.create(options);
+        // Here is our workflow graph
+        PCollection<KV<String, Long>> wordCount = p
+            .apply("(1) Read all lines", TextIO.read().from(inputFilePath))
+            .apply("(2) Flatmap to a list of words", FlatMapElements.into(TypeDescriptors.strings())
+                .via(line -> Arrays.asList(line.split("\\s"))))
+            .apply("(3) Lowercase all", MapElements.into(TypeDescriptors.strings())
+                .via(word -> word.toLowerCase()))
+            .apply("(4) Trim punctuations", MapElements.into(TypeDescriptors.strings())
+                .via(word -> trim(word)))
+            .apply("(5) Filter stopwords", Filter.by(word -> !isStopWord(word)))
+            .apply("(6) Count words", Count.perElement());
+        // We convert the PCollection to String so that we can write it to file
+        wordCount.apply(MapElements.into(TypeDescriptors.strings())
+                .via(count -> count.getKey() + " --> " + count.getValue()))
+            .apply(TextIO.write().to(outputFilePath));
+        // Finally we must run the pipeline, otherwise it's only a definition
+        p.run().waitUntilFinish();  
+        return true;
+    }
+    
+    public static boolean isStopWord(String word) {
+        String[] stopwords = {"am", "are", "is", "i", "you", "me",
+                               "he", "she", "they", "them", "was",
+                               "were", "from", "in", "of", "to", "be",
+                               "him", "her", "us", "and", "or"};
+        for (String stopword : stopwords) {
+            if (stopword.compareTo(word) == 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    public static String trim(String word) {
+        return word.replace("(","")
+            .replace(")", "")
+            .replace(",", "")
+            .replace(".", "")
+            .replace("\"", "")
+            .replace("'", "")
+            .replace(":", "")
+            .replace(";", "")
+            .replace("-", "")
+            .replace("?", "")
+            .replace("!", "");
+    }
+
+}

apache-beam/src/test/java/com/baeldung/apache/beam/intro/WordCountUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.apache.beam.intro;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import com.baeldung.apache.beam.intro.WordCount;
+
+public class WordCountUnitTest {
+    
+    @Test
+    // @Ignore
+    public void givenInputFile_whenWordCountRuns_thenJobFinishWithoutError() {
+        boolean jobDone = WordCount.wordCount("src/test/resources/wordcount.txt", "target/output");
+        assertTrue(jobDone);
+    }
+
+}

apache-beam/src/test/resources/wordcount.txt

@@ -0,0 +1,16 @@
+We've all heard the scare stories about North Korea: the homemade nuclear arsenal built while their people starve and then aimed imprecisely at the rest of the world, a 
+leader so deluded he makes L Ron Hubbard look like a man excessively overburdened with self-doubt and their deep-seated belief that foreign capitalists will invade at any 
+moment and steal all their bauxite.
+The popular portrayal of this Marxist nation is something like one of the more harrowing episodes of M*A*S*H, only with the cast of wacky characters replaced by twitchy, 
+heavily armed Stalinist meth addicts
+Cracked would like to take a moment to celebrate the good things about North Korea though, the things that the country's enemies prefer to suppress as part of their politically 
+motivated jealousy. Like how no different to you and me, there's nothing every North Korean likes more after an 18 hour shift at the phosphorus plant than a nice beer to go with 
+his dried fish ration. Ever attentive to its people's needs and in the twinkling of a decade, North Korea's leadership bought, disassembled, transported and rebuilt a British 
+brewery in order to discover and reproduce the secrets of beer and then brew the sweet nectar for its hardworking people, up to 18 bottles at a time. And with minimal fatalities. 
+When was the last time YOUR leader got a beer for YOU, American? (NB do not answer this question if you are Henry Louis Gates).
+Or how about the fried chicken restaurant that downtown Pyongyang boasts? Yes real chicken, fried and then delivered to your sleeping cube, with optional beer if you like! You 
+don't even have to remove the feathers or pull out the gizzard yourself. Mostly. Americans must eat their fried chicken from a bucket, like swine, sold by a company so secretive 
+that even the very blend of seasoning used is intentionally kept from them. And they call North Korea paranoid?
+And how many nations would entertain the syphilitic, bourgeois ramblings of Bill Clinton let alone permit him anywhere near their proud womenfolk? Only wise Kim Jong Il could see 
+past Bill's many, many imperfections and treat him with the pity and kindness he deserves, accepting his feeble pleas to pardon the American spies rightly convicted of photographing 
+the nation's sensitive beetroot fields.

apache-poi/README.md

@@ -6,3 +6,6 @@ This module contains articles about Apache POI
 - [Microsoft Word Processing in Java with Apache POI](https://www.baeldung.com/java-microsoft-word-with-apache-poi)
 - [Working with Microsoft Excel in Java](https://www.baeldung.com/java-microsoft-excel)
 - [Creating a MS PowerPoint Presentation in Java](https://www.baeldung.com/apache-poi-slideshow)
+- [Merge Cells in Excel Using Apache POI](https://www.baeldung.com/java-apache-poi-merge-cells)
+- [Get String Value of Excel Cell with Apache POI](https://www.baeldung.com/java-apache-poi-cell-string-value)
+- [Read Excel Cell Value Rather Than Formula With Apache POI](https://github.com/eugenp/tutorials/tree/master/apache-poi)

apache-poi/src/test/java/com/baeldung/poi/excel/merge/ExcelCellMergerUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.poi.excel.merge;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ExcelCellMergerUnitTest {
+    private static final String FILE_NAME = "ExcelCellFormatterTest.xlsx";
+    private String fileLocation;
+
+    @Before
+    public void setup() throws IOException, URISyntaxException {
+            fileLocation = Paths.get(ClassLoader.getSystemResource(FILE_NAME).toURI()).toString();
+    }
+
+    @Test
+    public void givenCellIndex_whenAddMergeRegion_thenMergeRegionCreated() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+
+        assertEquals(0, sheet.getNumMergedRegions());
+        int firstRow = 0; 
+        int lastRow = 0; 
+        int firstCol = 0; 
+        int lastCol = 2;
+        sheet.addMergedRegion(new CellRangeAddress(firstRow, lastRow, firstCol, lastCol));
+        assertEquals(1, sheet.getNumMergedRegions());
+
+        workbook.close();
+    }
+
+    @Test
+    public void givenCellRefString_whenAddMergeRegion_thenMergeRegionCreated() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+
+        assertEquals(0, sheet.getNumMergedRegions());        
+        sheet.addMergedRegion(CellRangeAddress.valueOf("A1:C1"));
+        assertEquals(1, sheet.getNumMergedRegions());
+
+        workbook.close();
+    }
+
+}

apache-rocketmq/README.md

@@ -3,3 +3,5 @@
 This module contains articles about Apache RocketMQ
 
 ### Relevant Articles: 
+
+- [Apache RocketMQ with Spring Boot](https://www.baeldung.com/apache-rocketmq-spring-boot)

apache-spark/README.md

@@ -7,4 +7,4 @@ This module contains articles about Apache Spark
 - [Introduction to Apache Spark](https://www.baeldung.com/apache-spark)
 - [Building a Data Pipeline with Kafka, Spark Streaming and Cassandra](https://www.baeldung.com/kafka-spark-data-pipeline)
 - [Machine Learning with Spark MLlib](https://www.baeldung.com/spark-mlib-machine-learning)
-
+- [Introduction to Spark Graph Processing with GraphFrames](https://www.baeldung.com/spark-graph-graphframes)

apache-tapestry/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles
+
+- [Intro to Apache Tapestry](https://www.baeldung.com/apache-tapestry)

aws-reactive/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [AWS S3 with Java – Reactive Support](https://www.baeldung.com/java-aws-s3-reactive)

blade/pom.xml

@@ -106,7 +106,7 @@
                             <arguments>
                                 <argument>java</argument>
                                 <argument>-jar</argument>
-                                <argument>sample-blade-app.jar</argument>
+                                <argument>blade.jar</argument>
                             </arguments>
                         </configuration>
                     </execution>

cdi/pom.xml

@@ -26,8 +26,8 @@
         </dependency>
         <dependency>
             <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest-core</artifactId>
+            <artifactId>hamcrest</artifactId>
-            <version>${org.hamcrest.version}</version>
+            <version>${hamcrest.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>

core-groovy-2/pom.xml

@@ -77,7 +77,7 @@
                     <dependency>
                         <groupId>org.codehaus.groovy</groupId>
                         <artifactId>groovy-eclipse-compiler</artifactId>
-                        <version>3.3.0-01</version>
+                        <version>${groovy.compiler.version}</version>
                     </dependency>
                     <dependency>
                         <groupId>org.codehaus.groovy</groupId>

core-groovy-2/src/test/groovy/com/baeldung/category/CategoryUnitTest.groovy

@@ -28,17 +28,16 @@ class CategoryUnitTest extends GroovyTestCase {
         }
     }
 
-//	http://team.baeldung.com/browse/BAEL-20687
+    void test_whenUsingTimeCategory_thenOperationOnNumber() {
-//    void test_whenUsingTimeCategory_thenOperationOnNumber() {
+        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy")
-//        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy")
+        use (TimeCategory) {
-//        use (TimeCategory) {
+            assert sdf.format(5.days.from.now) == sdf.format(new Date() + 5.days)
-//            assert sdf.format(5.days.from.now) == sdf.format(new Date() + 5.days)
+
-//
+            sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
-//            sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
+            assert sdf.format(10.minutes.from.now) == sdf.format(new Date() + 10.minutes)
-//            assert sdf.format(10.minutes.from.now) == sdf.format(new Date() + 10.minutes)
+            assert sdf.format(2.hours.ago) == sdf.format(new Date() - 2.hours)
-//            assert sdf.format(2.hours.ago) == sdf.format(new Date() - 2.hours)
+        }
-//        }
+    }
-//    }
 
     void test_whenUsingDOMCategory_thenOperationOnXML() {
 

core-groovy-2/src/test/groovy/com/baeldung/webservice/WebserviceUnitTest.groovy

@@ -75,7 +75,6 @@ class WebserviceManualTest extends GroovyTestCase {
         assert stories.size() == 5
     }
     
-    /* see BAEL-3753
     void test_whenConsumingSoap_thenReceiveResponse() {
         def url = "http://www.dataaccess.com/webservicesserver/numberconversion.wso"
         def soapClient = new SOAPClient(url)
@@ -90,7 +89,6 @@ class WebserviceManualTest extends GroovyTestCase {
         def words = response.NumberToWordsResponse
         assert words == "one thousand two hundred and thirty four "
     }
-    */
 
     void test_whenConsumingRestGet_thenReceiveResponse() {
         def path = "/get"

core-groovy/src/test/groovy/com/baeldung/file/ReadFileUnitTest.groovy

@@ -33,7 +33,6 @@ class ReadFileUnitTest extends Specification {
             assert lines.size(), 3
     }
     
-    @Ignore
     def 'Should return file content in string using ReadFile.readFileString given filePath' () {
         given:
             def filePath = "src/main/resources/fileContent.txt"

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

@@ -13,3 +13,4 @@ This module contains articles about Java 11 core features
 - [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)
 - [Benchmark JDK Collections vs Eclipse Collections](https://www.baeldung.com/jdk-collections-vs-eclipse-collections)
+- [Pre-compile Regex Patterns Into Pattern Objects](https://www.baeldung.com/java-regex-pre-compile)

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

@@ -65,7 +65,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
-                <version>3.2.1</version>
+                <version>${shade.plugin.version}</version>
                 <executions>
                     <execution>
                         <phase>package</phase>
@@ -109,6 +109,7 @@
         <uberjar.name>benchmarks</uberjar.name>
         <jmh.version>1.22</jmh.version>
         <eclipse.collections.version>10.0.0</eclipse.collections.version>
+        <shade.plugin.version>10.0.0</shade.plugin.version>
     </properties>
 
 </project>

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

@@ -0,0 +1,4 @@
+### Relevant articles:
+
+- [Java Switch Statement](https://www.baeldung.com/java-switch)
+- [New Java 13 Features](https://www.baeldung.com/java-13-new-features)

core-java-modules/core-java-14/.mvn/jvm.config

@@ -0,0 +1 @@
+--enable-preview

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

@@ -0,0 +1,7 @@
+## Core Java 14
+
+This module contains articles about Java 14. 
+
+### Relevant articles
+
+- [Guide to the @Serial Annotation in Java 14](https://www.baeldung.com/java-14-serial-annotation)

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

@@ -1,53 +1,66 @@
 <?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"
+         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>
+    <modelVersion>4.0.0</modelVersion>
-	<groupId>com.baeldung</groupId>
+    <artifactId>core-java-14</artifactId>
-	<artifactId>core-java-14</artifactId>
+    <name>core-java-14</name>
-	<version>1.0.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
-	<name>core-java-14</name>
+    <url>http://maven.apache.org</url>
-	<packaging>jar</packaging>
-	<url>http://maven.apache.org</url>
 
-	<parent>
+    <parent>
-		<groupId>com.baeldung</groupId>
+        <groupId>com.baeldung</groupId>
-		<artifactId>parent-modules</artifactId>
+        <artifactId>parent-modules</artifactId>
-		<version>1.0.0-SNAPSHOT</version>
+        <version>1.0.0-SNAPSHOT</version>
-		<relativePath>../../</relativePath>
+        <relativePath>../../</relativePath>
-	</parent>
+    </parent>
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junit-jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit-jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <release>${maven.compiler.release}</release>
+                    <compilerArgs>--enable-preview</compilerArgs>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${surefire.plugin.version}</version>
+                <configuration>
+                    <argLine>--enable-preview</argLine>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
-	<build>
+    <properties>
-		<plugins>
+        <maven.compiler.release>14</maven.compiler.release>
-			<plugin>
+        <assertj.version>3.6.1</assertj.version>
-				<groupId>org.apache.maven.plugins</groupId>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<version>${maven-compiler-plugin.version}</version>
-				<configuration>
-					<source>${maven.compiler.source.version}</source>
-					<target>${maven.compiler.target.version}</target>
-					<compilerArgs>
-						<compilerArg>
-							--enable-preview
-						</compilerArg>
-					</compilerArgs>
-				</configuration>
-			</plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>${surefire.plugin.version}</version>
-				<configuration>
-					<argLine>--enable-preview</argLine>
-				</configuration>
-			</plugin>
-		</plugins>
-	</build>
-
-	<properties>
-		<maven.compiler.source.version>14</maven.compiler.source.version>
-		<maven.compiler.target.version>14</maven.compiler.target.version>
         <surefire.plugin.version>3.0.0-M3</surefire.plugin.version>
-	</properties>
+    </properties>
 
 </project>

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/patternmatchingforinstanceof/PatternMatchingForInstanceOf.java

@@ -0,0 +1,26 @@
+package com.baeldung.java14.patternmatchingforinstanceof;
+
+public class PatternMatchingForInstanceOf {
+
+    public void performAnimalOperations(Animal animal) {
+         if (animal instanceof Cat cat) {
+             cat.meow();
+         } else if(animal instanceof Dog dog) {
+             dog.woof();
+         }
+    }
+
+    abstract class Animal {
+    }
+
+    final class Cat extends Animal {
+        void meow() {
+        }
+    }
+
+    final class Dog extends Animal {
+        void woof() {
+        }
+    }
+
+}

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/textblocks/TextBlocks13.java

@@ -0,0 +1,46 @@
+package com.baeldung.java14.textblocks;
+
+public class TextBlocks13 {
+    public String getBlockOfHtml() {
+        return """
+            <html>
+
+                <body>
+                    <span>example text</span>
+                </body>
+            </html>""";
+    }
+
+    public String getNonStandardIndent() {
+        return """
+                Indent
+            """;
+    }
+
+    public String getQuery() {
+        return """
+            select "id", "user"
+            from "table"
+            """;
+    }
+
+    public String getTextWithCarriageReturns() {
+        return """
+            separated with\r
+            carriage returns""";
+    }
+
+    public String getTextWithEscapes() {
+        return """
+            fun with\n
+            whitespace\t\r
+            and other escapes \"""
+            """;
+    }
+
+    public String getFormattedText(String parameter) {
+        return """
+            Some parameter: %s
+            """.formatted(parameter);
+    }
+}

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/textblocks/TextBlocks14.java

@@ -0,0 +1,16 @@
+package com.baeldung.java14.textblocks;
+
+public class TextBlocks14 {
+    public String getIgnoredNewLines() {
+        return """
+            This is a long test which looks to \
+            have a newline but actually does not""";
+    }
+
+    public String getEscapedSpaces() {
+        return """
+            line 1
+            line 2       \s
+            """;
+    }
+}

core-java-modules/core-java-14/src/main/java/com/baeldung/serial/MySerialClass.java

@@ -10,41 +10,41 @@ import java.io.Serializable;
 
 /**
  * Class showcasing the usage of the Java 14 @Serial annotation.
- * 
+ *
  * @author Donato Rimenti
  */
 public class MySerialClass implements Serializable {
-	
-	@Serial
-	private static final ObjectStreamField[] serialPersistentFields = null;
-	
-	@Serial
-	private static final long serialVersionUID = 1;
 
-	@Serial
+    @Serial
-	private void writeObject(ObjectOutputStream stream) throws IOException {
+    private static final ObjectStreamField[] serialPersistentFields = null;
-		// ...
-	}
 
-	@Serial
+    @Serial
-	private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
+    private static final long serialVersionUID = 1;
-		// ...
-	}
 
-	@Serial
+    @Serial
-	private void readObjectNoData() throws ObjectStreamException {
+    private void writeObject(ObjectOutputStream stream) throws IOException {
-		// ...
+        // ...
-	}
+    }
 
-	@Serial
+    @Serial
-	private Object writeReplace() throws ObjectStreamException {
+    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
-		// ...
+        // ...
-		return null;
+    }
-	}
 
-	@Serial
+    @Serial
-	private Object readResolve() throws ObjectStreamException {
+    private void readObjectNoData() throws ObjectStreamException {
-		// ...
+        // ...
-		return null;
+    }
-	}
+
+    @Serial
+    private Object writeReplace() throws ObjectStreamException {
+        // ...
+        return null;
+    }
+
+    @Serial
+    private Object readResolve() throws ObjectStreamException {
+        // ...
+        return null;
+    }
 }

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/patternmatchingforinstanceof/PatternMatchingForInstanceOfUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.java14.patternmatchingforinstanceof;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.java14.patternmatchingforinstanceof.PatternMatchingForInstanceOf.Cat;
+import com.baeldung.java14.patternmatchingforinstanceof.PatternMatchingForInstanceOf.Dog;
+
+class PatternMatchingForInstanceOfUnitTest {
+
+    @Test
+    void givenAnAnimal_whenTypeIsCat_ThenCatGoesMeow() {
+        Cat animal = mock(Cat.class);
+
+        PatternMatchingForInstanceOf instanceOf = new PatternMatchingForInstanceOf();
+        instanceOf.performAnimalOperations(animal);
+
+        verify(animal).meow();
+    }
+
+    @Test
+    void givenAnAnimal_whenTypeIsDog_ThenDogGoesWoof() {
+        Dog animal = mock(Dog.class);
+
+        PatternMatchingForInstanceOf instanceOf = new PatternMatchingForInstanceOf();
+        instanceOf.performAnimalOperations(animal);
+
+        verify(animal).woof();
+    }
+
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/textblocks/TextBlocks13UnitTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.java14.textblocks;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class TextBlocks13UnitTest {
+    private TextBlocks13 subject = new TextBlocks13();
+
+    @Test
+    void givenAnOldStyleMultilineString_whenComparing_thenEqualsTextBlock() {
+        String expected = "<html>\n"
+          + "\n"
+          + "    <body>\n"
+          + "        <span>example text</span>\n"
+          + "    </body>\n"
+          + "</html>";
+        assertThat(subject.getBlockOfHtml()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAnOldStyleString_whenComparing_thenEqualsTextBlock() {
+        String expected = "<html>\n\n    <body>\n        <span>example text</span>\n    </body>\n</html>";
+        assertThat(subject.getBlockOfHtml()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAnIndentedString_thenMatchesIndentedOldStyle() {
+        assertThat(subject.getNonStandardIndent()).isEqualTo("    Indent\n");
+    }
+
+    @Test
+    void givenAMultilineQuery_thenItCanContainUnescapedQuotes() {
+        assertThat(subject.getQuery()).contains("select \"id\", \"user\"");
+    }
+
+    @Test
+    void givenAMultilineQuery_thenItEndWithANewline() {
+        assertThat(subject.getQuery()).endsWith("\n");
+    }
+
+    @Test
+    void givenATextWithCarriageReturns_thenItContainsBoth() {
+        assertThat(subject.getTextWithCarriageReturns()).isEqualTo("separated with\r\ncarriage returns");
+    }
+
+    @Test
+    void givenAStringWithEscapedWhitespace_thenItAppearsInTheResultingString() {
+        assertThat(subject.getTextWithEscapes()).contains("fun with\n\n")
+            .contains("whitespace\t\r\n")
+            .contains("and other escapes \"\"\"");
+    }
+
+    @Test
+    void givenAFormattedString_thenTheParameterIsReplaced() {
+        assertThat(subject.getFormattedText("parameter")).contains("Some parameter: parameter");
+    }
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/textblocks/TextBlocks14UnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.java14.textblocks;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class TextBlocks14UnitTest {
+    private TextBlocks14 subject = new TextBlocks14();
+
+    @Test
+    void givenAStringWithEscapedNewLines_thenTheResultHasNoNewLines() {
+        String expected = "This is a long test which looks to have a newline but actually does not";
+        assertThat(subject.getIgnoredNewLines()).isEqualTo(expected);
+    }
+
+    @Test
+    void givenAStringWithEscapesSpaces_thenTheResultHasLinesEndingWithSpaces() {
+        String expected = "line 1\nline 2        \n";
+        assertThat(subject.getEscapedSpaces()).isEqualTo(expected);
+    }
+}

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

@@ -61,7 +61,7 @@
                         </goals>
                         <configuration>
                             <classifier>spring-boot</classifier>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                         </configuration>
                     </execution>
                 </executions>

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

@@ -9,6 +9,7 @@ This module contains articles about Java 9 core features
 - [Iterate Through a Range of Dates in Java](https://www.baeldung.com/java-iterate-date-range)
 - [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
 - [Immutable Set in Java](https://www.baeldung.com/java-immutable-set)
+- [Immutable ArrayList in Java](https://www.baeldung.com/java-immutable-list)
 
 Note: also contains part of the code for the article
 [How to Filter a Collection in Java](https://www.baeldung.com/java-collection-filtering).

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

@@ -37,6 +37,11 @@
             <version>${junit.platform.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -69,6 +74,7 @@
         <maven.compiler.source>1.9</maven.compiler.source>
         <maven.compiler.target>1.9</maven.compiler.target>
         <guava.version>25.1-jre</guava.version>
+        <commons-collections4.version>4.1</commons-collections4.version>
     </properties>
 
 </project>

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/list/immutable/ImmutableArrayListUnitTest.java

@@ -1,56 +1,48 @@
-package org.baeldung.java.collections;
+package com.baeldung.java9.list.immutable;
 
 import com.google.common.collect.ImmutableList;
 import org.apache.commons.collections4.ListUtils;
 import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-public class CoreJavaCollectionsUnitTest {
+public class ImmutableArrayListUnitTest {
-
-    private static final Logger LOG = LoggerFactory.getLogger(CoreJavaCollectionsUnitTest.class);
-
-
-    // tests -
-
-    @Test
-    public final void givenUsingTheJdk_whenArrayListIsSynchronized_thenCorrect() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
-        final List<String> synchronizedList = Collections.synchronizedList(list);
-        LOG.debug("Synchronized List is: " + synchronizedList);
-    }
 
     @Test(expected = UnsupportedOperationException.class)
-    public final void givenUsingTheJdk_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
+    public final void givenUsingTheJdk_whenUnmodifiableListIsCreated_thenNotModifiable() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
         final List<String> unmodifiableList = Collections.unmodifiableList(list);
         unmodifiableList.add("four");
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public final void givenUsingGuava_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
+    public final void givenUsingTheJava9_whenUnmodifiableListIsCreated_thenNotModifiable() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
+        final List<String> unmodifiableList = List.of(list.toArray(new String[]{}));
+        unmodifiableList.add("four");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public final void givenUsingGuava_whenUnmodifiableListIsCreated_thenNotModifiable() {
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
         final List<String> unmodifiableList = ImmutableList.copyOf(list);
         unmodifiableList.add("four");
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public final void givenUsingGuavaBuilder_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
+    public final void givenUsingGuavaBuilder_whenUnmodifiableListIsCreated_thenNoLongerModifiable() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
         final ImmutableList<String> unmodifiableList = ImmutableList.<String>builder().addAll(list).build();
         unmodifiableList.add("four");
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public final void givenUsingCommonsCollections_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
+    public final void givenUsingCommonsCollections_whenUnmodifiableListIsCreated_thenNotModifiable() {
-        final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
         final List<String> unmodifiableList = ListUtils.unmodifiableList(list);
         unmodifiableList.add("four");
     }
-
 }

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

@@ -13,4 +13,5 @@ This module contains articles about Java arrays
 - [Removing an Element from an Array in Java](https://www.baeldung.com/java-array-remove-element)
 - [Removing the First Element of an Array](https://www.baeldung.com/java-array-remove-first-element)
 - [Adding an Element to a Java Array vs an ArrayList](https://www.baeldung.com/java-add-element-to-array-vs-list)
+- [Arrays.sort vs Arrays.parallelSort](https://www.baeldung.com/java-arrays-sort-vs-parallelsort)
 - [[<-- Prev]](/core-java-modules/core-java-arrays)

core-java-modules/core-java-arrays-2/src/test/java/com/baeldung/arraysort/SortComparisonUnitTest.java

@@ -69,7 +69,7 @@ public class SortComparisonUnitTest {
     }
 
     @Test
-    public void givenArrayOfIntegers_whenUsingArraysSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
+    public void givenArrayOfIntegers_whenUsingArraysSortWithRange_thenSortRangeOfArrayAsc() {
         int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
         int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
 
@@ -89,7 +89,7 @@ public class SortComparisonUnitTest {
     }
 
     @Test
-    public void givenArrayOfIntegers_whenUsingArraysParallelSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
+    public void givenArrayOfIntegers_whenUsingArraysParallelSortWithRange_thenSortRangeOfArrayAsc() {
         int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
         int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
 

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

@@ -75,7 +75,7 @@
                         <manifest>
                             <addClasspath>true</addClasspath>
                             <classpathPrefix>libs/</classpathPrefix>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                         </manifest>
                     </archive>
                 </configuration>
@@ -94,7 +94,7 @@
                             <archiveBaseDirectory>${project.basedir}</archiveBaseDirectory>
                             <archive>
                                 <manifest>
-                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                                    <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                                 </manifest>
                             </archive>
                             <descriptorRefs>
@@ -118,7 +118,7 @@
                             <shadedArtifactAttached>true</shadedArtifactAttached>
                             <transformers>
                                 <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                                    <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                                 </transformer>
                             </transformers>
                         </configuration>
@@ -133,7 +133,7 @@
                 <executions>
                     <execution>
                         <configuration>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                             <attachToBuild>true</attachToBuild>
                             <filename>${project.build.finalName}-onejar.${project.packaging}</filename>
                         </configuration>
@@ -155,7 +155,7 @@
                         </goals>
                         <configuration>
                             <classifier>spring-boot</classifier>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                         </configuration>
                     </execution>
                 </executions>

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

@@ -1,20 +0,0 @@
-package com.baeldung.array;
-
-public class Find2ndLargestInArray {
-
-    public static int find2ndLargestElement(int[] array) {
-        int maxElement = array[0];
-        int secondLargestElement = -1;
-
-        for (int index = 0; index < array.length; index++) {
-            if (maxElement <= array[index]) {
-                secondLargestElement = maxElement;
-                maxElement = array[index];
-            } else if (secondLargestElement < array[index]) {
-                secondLargestElement = array[index];
-            }
-        }
-        return secondLargestElement;
-    }
-
-}

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

@@ -1,22 +0,0 @@
-package com.baeldung.array;
-
-import java.util.Arrays;
-
-public class FindElementInArray {
-
-    public static boolean findGivenElementInArrayWithoutUsingStream(int[] array, int element) {
-        boolean actualResult = false;
-
-        for (int index = 0; index < array.length; index++) {
-            if (element == array[index]) {
-                actualResult = true;
-                break;
-            }
-        }
-        return actualResult;
-    }
-
-    public static boolean findGivenElementInArrayUsingStream(int[] array, int element) {
-        return Arrays.stream(array).filter(x -> element == x).findFirst().isPresent();
-    }
-}

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

@@ -1,16 +0,0 @@
-package com.baeldung.array;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-public class Find2ndLargestInArrayUnitTest {
-    @Test
-    public void givenAnIntArray_thenFind2ndLargestElement() {
-        int[] array = { 1, 3, 24, 16, 87, 20 };
-        int expected2ndLargest = 24;
-
-        int actualSecondLargestElement = Find2ndLargestInArray.find2ndLargestElement(array);
-
-        Assert.assertEquals(expected2ndLargest, actualSecondLargestElement);
-    }
-}

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

@@ -1,35 +0,0 @@
-package com.baeldung.array;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-public class FindElementInArrayUnitTest {
-    @Test
-    public void givenAnIntArray_whenNotUsingStream_thenFindAnElement() {
-        int[] array = { 1, 3, 4, 8, 19, 20 };
-        int element = 19;
-        boolean expectedResult = true;
-        boolean actualResult = FindElementInArray.findGivenElementInArrayWithoutUsingStream(array, element);
-        Assert.assertEquals(expectedResult, actualResult);
-
-        element = 78;
-        expectedResult = false;
-        actualResult = FindElementInArray.findGivenElementInArrayWithoutUsingStream(array, element);
-        Assert.assertEquals(expectedResult, actualResult);
-    }
-
-    @Test
-    public void givenAnIntArray_whenUsingStream_thenFindAnElement() {
-        int[] array = { 15, 16, 12, 18 };
-        int element = 16;
-        boolean expectedResult = true;
-        boolean actualResult = FindElementInArray.findGivenElementInArrayUsingStream(array, element);
-        Assert.assertEquals(expectedResult, actualResult);
-
-        element = 20;
-        expectedResult = false;
-        actualResult = FindElementInArray.findGivenElementInArrayUsingStream(array, element);
-        Assert.assertEquals(expectedResult, actualResult);
-    }
-
-}

core-java-modules/core-java-collections-array-list/README.md

@@ -3,9 +3,8 @@
 This module contains articles about the Java ArrayList collection
 
 ### Relevant Articles: 
-- [Immutable ArrayList in Java](http://www.baeldung.com/java-immutable-list)
+- [Guide to the Java ArrayList](https://www.baeldung.com/java-arraylist)
-- [Guide to the Java ArrayList](http://www.baeldung.com/java-arraylist)
+- [Add Multiple Items to an Java ArrayList](https://www.baeldung.com/java-add-items-array-list)
-- [Add Multiple Items to an Java ArrayList](http://www.baeldung.com/java-add-items-array-list)
 - [ClassCastException: Arrays$ArrayList cannot be cast to ArrayList](https://www.baeldung.com/java-classcastexception-arrays-arraylist)
 - [Multi Dimensional ArrayList in Java](https://www.baeldung.com/java-multi-dimensional-arraylist)
 - [Removing an Element From an ArrayList](https://www.baeldung.com/java-arraylist-remove-element)

core-java-modules/core-java-collections-array-list/src/test/java/com/baeldung/collections/ArrayListUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.collections;
+package com.baeldung.collections;
 
 import com.google.common.collect.Sets;
 import org.junit.Before;

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

@@ -0,0 +1,25 @@
+package com.baeldung.collections;
+
+import com.google.common.collect.ImmutableList;
+import org.apache.commons.collections4.ListUtils;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class CoreJavaCollectionsUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(CoreJavaCollectionsUnitTest.class);
+
+    @Test
+    public final void givenUsingTheJdk_whenArrayListIsSynchronized_thenCorrect() {
+        final List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three"));
+        final List<String> synchronizedList = Collections.synchronizedList(list);
+        LOG.debug("Synchronized List is: " + synchronizedList);
+    }
+
+}

core-java-modules/core-java-collections-list-2/README.md

@@ -3,13 +3,13 @@
 This module contains articles about the Java List collection
 
 ### Relevant Articles: 
-- [Check If Two Lists are Equal in Java](http://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)
+- [Check If Two Lists are Equal in Java](https://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)
 - [Java 8 Streams: Find Items From One List Based On Values From Another List](https://www.baeldung.com/java-streams-find-list-items)
-- [A Guide to the Java LinkedList](http://www.baeldung.com/java-linkedlist)
+- [A Guide to the Java LinkedList](https://www.baeldung.com/java-linkedlist)
-- [Java List UnsupportedOperationException](http://www.baeldung.com/java-list-unsupported-operation-exception)
+- [Java List UnsupportedOperationException](https://www.baeldung.com/java-list-unsupported-operation-exception)
 - [Java List Initialization in One Line](https://www.baeldung.com/java-init-list-one-line)
 - [Ways to Iterate Over a List in Java](https://www.baeldung.com/java-iterate-list)
-- [Flattening Nested Collections in Java](http://www.baeldung.com/java-flatten-nested-collections)
+- [Flattening Nested Collections in Java](https://www.baeldung.com/java-flatten-nested-collections)
 - [Intersection of Two Lists in Java](https://www.baeldung.com/java-lists-intersection)
 - [Searching for a String in an ArrayList](https://www.baeldung.com/java-search-string-arraylist)
 - [[<-- Prev]](/core-java-modules/core-java-collections-list)[[Next -->]](/core-java-modules/core-java-collections-list-3)

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListAssertJUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Test;
 

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListJUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Assert;
 import org.junit.Test;

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListTestNgUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Test;
 

core-java-modules/core-java-collections-list-2/src/test/java/org/baeldung/java/lists/README.md

@@ -1,2 +0,0 @@
-### Relevant Articles:
-- [Check If Two Lists are Equal in Java](http://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)

core-java-modules/core-java-collections-list/src/test/java/com/baeldung/collections/JavaCollectionCleanupUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.collections;
+package com.baeldung.collections;
 
 import static org.hamcrest.Matchers.hasSize;
 import static org.junit.Assert.assertThat;

core-java-modules/core-java-collections-list/src/test/java/com/baeldung/list/random/RandomListElementUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung;
+package com.baeldung.list.random;
 
 import com.google.common.collect.Lists;
 import org.junit.Test;

core-java-modules/core-java-concurrency-advanced-2/src/main/java/com/baeldung/threadlocalrandom/ThreadLocalRandomBenchMarkRunner.java

@@ -1,22 +1,27 @@
 package com.baeldung.threadlocalrandom;
 
 import org.openjdk.jmh.runner.Runner;
-import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.ChainedOptionsBuilder;
 import org.openjdk.jmh.runner.options.OptionsBuilder;
 
+import com.google.common.collect.ImmutableList;
+
 public class ThreadLocalRandomBenchMarkRunner {
 
     public static void main(String[] args) throws Exception {
 
-        Options options = new OptionsBuilder().include(ThreadLocalRandomBenchMarker.class.getSimpleName())
+        ChainedOptionsBuilder options = new OptionsBuilder().include(ThreadLocalRandomBenchMarker.class.getSimpleName())
-            .threads(1)
             .forks(1)
             .shouldFailOnError(true)
             .shouldDoGC(true)
-            .jvmArgs("-server")
+            .jvmArgs("-server");
-            .build();
-
-        new Runner(options).run();
 
+        for (Integer i : ImmutableList.of(1, 2, 8, 32)) {
+            new Runner(
+                    options
+                            .threads(i)
+                            .build())
+                    .run();
+        }
     }
 }

core-java-modules/core-java-concurrency-advanced-2/src/main/java/com/baeldung/threadlocalrandom/ThreadLocalRandomBenchMarker.java

@@ -1,64 +1,34 @@
 package com.baeldung.threadlocalrandom;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Random;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Level;
 import org.openjdk.jmh.annotations.Mode;
 import org.openjdk.jmh.annotations.OutputTimeUnit;
 import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.Warmup;
 
-@BenchmarkMode(Mode.AverageTime)
+@BenchmarkMode(Mode.Throughput)
 @Warmup(iterations = 1)
 @OutputTimeUnit(TimeUnit.MICROSECONDS)
 @State(Scope.Benchmark)
 public class ThreadLocalRandomBenchMarker {
+    private final Random random = new Random();
 
-    List<Callable<Integer>> randomCallables = new ArrayList<>();
+    @Benchmark
-    List<Callable<Integer>> threadLocalRandomCallables = new ArrayList<>();
+    public int randomValuesUsingRandom() {
-
+        return random.nextInt();
-    @Setup(Level.Iteration)
-    public void init() {
-        Random random = new Random();
-        randomCallables = new ArrayList<>();
-        threadLocalRandomCallables = new ArrayList<>();
-        for (int i = 0; i < 1000; i++) {
-            randomCallables.add(() -> {
-                return random.nextInt();
-            });
-        }
-
-        for (int i = 0; i < 1000; i++) {
-            threadLocalRandomCallables.add(() -> {
-                return ThreadLocalRandom.current()
-                    .nextInt();
-            });
-        }
     }
 
     @Benchmark
-    public void randomValuesUsingRandom() throws InterruptedException {
+    public int randomValuesUsingThreadLocalRandom() {
-        ExecutorService executor = Executors.newWorkStealingPool();
+        return ThreadLocalRandom
-        executor.invokeAll(randomCallables);
+                .current()
-        executor.shutdown();
+                .nextInt();
-    }
-
-    @Benchmark
-    public void randomValuesUsingThreadLocalRandom() throws InterruptedException {
-        ExecutorService executor = Executors.newWorkStealingPool();
-        executor.invokeAll(threadLocalRandomCallables);
-        executor.shutdown();
     }
 
 }

core-java-modules/core-java-concurrency-advanced-3/README.md

@@ -8,4 +8,6 @@ This module contains articles about advanced topics about multithreading with co
 
 - [Common Concurrency Pitfalls in Java](https://www.baeldung.com/java-common-concurrency-pitfalls)
 - [Guide to RejectedExecutionHandler](https://www.baeldung.com/java-rejectedexecutionhandler)
-[[<-- previous]](/core-java-modules/core-java-concurrency-advanced-2)
+- [Guide to Work Stealing in Java](https://www.baeldung.com/java-work-stealing)
+- [Asynchronous Programming in Java](https://www.baeldung.com/java-asynchronous-programming)
+- [[<-- previous]](/core-java-modules/core-java-concurrency-advanced-2)

core-java-modules/core-java-concurrency-advanced/src/main/java/com/baeldung/concurrent/volatilekeyword/SharedObject.java

@@ -4,7 +4,7 @@ package com.baeldung.concurrent.volatilekeyword;
 public class SharedObject {
     private volatile int count=0;
 
-    void increamentCount(){
+    void incrementCount(){
         count++;
     }
     public int  getCount(){

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/volatilekeyword/SharedObjectManualTest.java

@@ -10,7 +10,7 @@ public class SharedObjectManualTest {
     public void whenOneThreadWrites_thenVolatileReadsFromMainMemory() throws InterruptedException {
         SharedObject sharedObject = new SharedObject();
 
-        Thread writer = new Thread(() -> sharedObject.increamentCount());
+        Thread writer = new Thread(() -> sharedObject.incrementCount());
         writer.start();
         Thread.sleep(100);
 
@@ -31,11 +31,11 @@ public class SharedObjectManualTest {
     @Test
     public void whenTwoThreadWrites_thenVolatileReadsFromMainMemory() throws InterruptedException {
         SharedObject sharedObject = new SharedObject();
-        Thread writerOne = new Thread(() -> sharedObject.increamentCount());
+        Thread writerOne = new Thread(() -> sharedObject.incrementCount());
         writerOne.start();
         Thread.sleep(100);
 
-        Thread writerTwo = new Thread(() -> sharedObject.increamentCount());
+        Thread writerTwo = new Thread(() -> sharedObject.incrementCount());
         writerTwo.start();
         Thread.sleep(100);
 

core-java-modules/core-java-concurrency-collections/src/test/java/com/baeldung/java/stream/ThreadPoolInParallelStreamIntegrationTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.streams;
+package com.baeldung.java.stream;
 
 import org.junit.Test;
 

core-java-modules/core-java-date-operations-2/README.md

@@ -6,4 +6,5 @@ This module contains articles about date operations in Java.
 - [Skipping Weekends While Adding Days to LocalDate in Java 8](https://www.baeldung.com/java-localdate-add-days-skip-weekends)
 - [Checking If Two Java Dates Are on the Same Day](https://www.baeldung.com/java-check-two-dates-on-same-day)
 - [Converting Java Date to OffsetDateTime](https://www.baeldung.com/java-convert-date-to-offsetdatetime)
+- [How to Set the JVM Time Zone](https://www.baeldung.com/java-jvm-time-zone)
 - [[<-- Prev]](/core-java-modules/core-java-date-operations-1)

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/offsetdatetime/ConvertToOffsetDateTimeUnitTest.java

@@ -4,6 +4,7 @@ import org.junit.Test;
 
 import java.time.OffsetDateTime;
 import java.util.Date;
+import java.util.TimeZone;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -18,12 +19,19 @@ public class ConvertToOffsetDateTimeUnitTest {
 
     @Test
     public void givenDate_whenHasOffset_thenConvertWithOffset() {
+        TimeZone prevTimezone = TimeZone.getDefault();
+        TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+
         Date date = new Date();
         date.setHours(6);
         date.setMinutes(30);
+
         OffsetDateTime odt = ConvertToOffsetDateTime.convert(date, 3, 30);
         assertEquals(10, odt.getHour());
         assertEquals(0, odt.getMinute());
+
+        // Reset the timezone to its original value to prevent side effects
+        TimeZone.setDefault(prevTimezone);
     }
 
 }

core-java-modules/core-java-datetime-java8-2/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [Creating a LocalDate with Values in Java](https://www.baeldung.com/java-creating-localdate-with-values)

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

@@ -2,4 +2,8 @@
 
 This module contains articles about core java exceptions
 
-###
+### Relevant Articles:
+
+- [Is It a Bad Practice to Catch Throwable?](https://www.baeldung.com/java-catch-throwable-bad-practice)
+- [Wrapping vs Rethrowing Exceptions in Java](https://www.baeldung.com/java-wrapping-vs-rethrowing-exceptions)
+- [java.net.UnknownHostException: Invalid Hostname for Server](https://www.baeldung.com/java-unknownhostexception)

core-java-modules/core-java-exceptions-2/src/main/java/com/baeldung/socketexception/SocketClient.java

@@ -0,0 +1,32 @@
+package com.baeldung.socketexception;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+
+public class SocketClient {
+
+    private Socket clientSocket;
+    private PrintWriter out;
+    private BufferedReader in;
+
+    public void startConnection(String ip, int port) throws IOException {
+        clientSocket = new Socket(ip, port);
+        out = new PrintWriter(clientSocket.getOutputStream(), true);
+        in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+    }
+
+    public String sendMessage(String msg) throws IOException {
+        out.println(msg);
+        return in.readLine();
+    }
+
+    public void stopConnection() throws IOException {
+        in.close();
+        out.close();
+        clientSocket.close();
+    }
+
+}

core-java-modules/core-java-exceptions-2/src/main/java/com/baeldung/socketexception/SocketServer.java

@@ -0,0 +1,45 @@
+package com.baeldung.socketexception;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+public class SocketServer {
+
+    private ServerSocket serverSocket;
+    private Socket clientSocket;
+    private PrintWriter out;
+    private BufferedReader in;
+
+    public void start(int port) {
+        try {
+            serverSocket = new ServerSocket(port);
+            clientSocket = serverSocket.accept();
+            out = new PrintWriter(clientSocket.getOutputStream(), true);
+            in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+            String msg = in.readLine();
+            if (msg.contains("hi"))
+                out.println("hi");
+            else
+                out.println("didn't understand");
+            close();
+            stop();
+        } catch (IOException e) {
+            
+        }
+    }
+
+    private void close() throws IOException {
+        in.close();
+        out.close();
+    }
+
+    private void stop() throws IOException {
+        clientSocket.close();
+        serverSocket.close();
+    }
+
+}

core-java-modules/core-java-exceptions-2/src/main/java/com/baeldung/suppressed/ExceptionalResource.java

@@ -0,0 +1,13 @@
+package com.baeldung.suppressed;
+
+public class ExceptionalResource implements AutoCloseable {
+    
+    public void processSomething() {
+        throw new IllegalArgumentException("Thrown from processSomething()");
+    }
+
+    @Override
+    public void close() throws Exception {
+        throw new NullPointerException("Thrown from close()");
+    }
+}

core-java-modules/core-java-exceptions-2/src/main/java/com/baeldung/suppressed/SuppressedExceptionsDemo.java

@@ -0,0 +1,44 @@
+package com.baeldung.suppressed;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class SuppressedExceptionsDemo {
+
+    public static void demoSuppressedException(String filePath) throws IOException {
+        FileInputStream fileIn = null;
+        try {
+            fileIn = new FileInputStream(filePath);
+        } catch (FileNotFoundException e) {
+            throw new IOException(e);
+        } finally {
+            fileIn.close();
+        }
+    }
+    
+    public static void demoAddSuppressedException(String filePath) throws IOException {
+        Throwable firstException = null;
+        FileInputStream fileIn = null;
+        try {
+            fileIn = new FileInputStream(filePath);
+        } catch (IOException e) {
+            firstException = e;
+        } finally {
+            try {
+                fileIn.close();
+            } catch (NullPointerException npe) {
+                if (firstException != null) {
+                    npe.addSuppressed(firstException);
+                }
+                throw npe;
+            }
+        }
+    }
+    
+    public static void demoExceptionalResource() throws Exception {
+        try (ExceptionalResource exceptionalResource = new ExceptionalResource()) {
+            exceptionalResource.processSomething();
+        }
+    }
+}

core-java-modules/core-java-exceptions-2/src/test/java/com/baeldung/socketexception/SocketExceptionHandlingUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.socketexception;
+
+import java.io.IOException;
+import java.net.SocketException;
+import java.util.concurrent.Executors;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class SocketExceptionHandlingUnitTest {
+
+    @BeforeClass
+    public static void runServer() throws IOException, InterruptedException {
+        Executors.newSingleThreadExecutor()
+            .submit(() -> new SocketServer().start(6699));
+        Thread.sleep(100);
+    }
+
+    @Test
+    public void givenRunningServer_whenConnectToClosedSocket_thenHandleException() throws IOException {
+        SocketClient client = new SocketClient();
+        client.startConnection("127.0.0.1", 6699);
+        try {
+            client.sendMessage("hi");
+            client.sendMessage("hi again");
+        } catch (SocketException e) {
+            client.stopConnection();
+        }
+    }
+
+}

core-java-modules/core-java-exceptions-2/src/test/java/com/baeldung/suppressed/SuppressedExceptionsUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.suppressed;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import org.junit.Test;
+import static org.hamcrest.CoreMatchers.instanceOf;
+
+public class SuppressedExceptionsUnitTest {
+
+    @Test(expected = NullPointerException.class)
+    public void givenNonExistentFileName_whenAttemptFileOpen_thenNullPointerException() throws IOException {
+        SuppressedExceptionsDemo.demoSuppressedException("/non-existent-path/non-existent-file.txt");
+    }
+    
+    @Test
+    public void givenNonExistentFileName_whenAttemptFileOpenStoreSuppressed_thenSuppressedExceptionAvailable() {
+        try {
+            SuppressedExceptionsDemo.demoAddSuppressedException("/non-existent-path/non-existent-file.txt");
+        } catch (Exception e) {
+            assertThat(e, instanceOf(NullPointerException.class));
+            assertEquals(1, e.getSuppressed().length);
+            assertThat(e.getSuppressed()[0], instanceOf(FileNotFoundException.class));
+        }
+    }
+    
+    @Test
+    public void whenUsingExceptionalResource_thenSuppressedExceptionAvailable() {
+        try {
+            SuppressedExceptionsDemo.demoExceptionalResource();
+        } catch (Exception e) {
+            assertThat(e, instanceOf(IllegalArgumentException.class));
+            assertEquals("Thrown from processSomething()", e.getMessage());
+            assertEquals(1, e.getSuppressed().length);
+            assertThat(e.getSuppressed()[0], instanceOf(NullPointerException.class));
+            assertEquals("Thrown from close()", e.getSuppressed()[0].getMessage());
+        }
+    }
+}

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

@@ -11,5 +11,5 @@ This module contains articles about core Java input and output (IO)
 - [List Files in a Directory in Java](https://www.baeldung.com/java-list-directory-files)
 - [Java – Append Data to a File](https://www.baeldung.com/java-append-to-file)
 - [How to Copy a File with Java](https://www.baeldung.com/java-copy-file)
-- [Create a Directory in Java](https://www.baeldung.com/java-create-directory)
+- [Create a Directory in Java](https://www.baeldung.com/java-create-directory) 
 - [[<-- Prev]](/core-java-modules/core-java-io)

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

@@ -13,4 +13,5 @@ This module contains articles about core Java input and output (IO)
 - [Getting a File’s Mime Type in Java](https://www.baeldung.com/java-file-mime-type)
 - [How to Write to a CSV File in Java](https://www.baeldung.com/java-csv)
 - [How to Avoid the Java FileNotFoundException When Loading Resources](https://www.baeldung.com/java-classpath-resource-cannot-be-opened)
+- [Create a Directory in Java](https://www.baeldung.com/java-create-directory)
 - [[More -->]](/core-java-modules/core-java-io-2)

core-java-modules/core-java-io/src/test/java/com/baeldung/readfile/FileOperationsManualTest.java

@@ -1,134 +0,0 @@
-package com.baeldung.readfile;
-
-import org.apache.commons.io.FileUtils;
-import org.apache.commons.io.IOUtils;
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.Matchers;
-import org.junit.Test;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.net.URISyntaxException;
-import java.net.URL;
-import java.net.URLConnection;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-
-public class FileOperationsManualTest {
-
-    @Test
-    public void givenFileName_whenUsingClassloader_thenFileData() throws IOException {
-        String expectedData = "Hello World from fileTest.txt!!!";
-
-        ClassLoader classLoader = getClass().getClassLoader();
-        File file = new File(classLoader.getResource("fileTest.txt").getFile());
-        InputStream inputStream = new FileInputStream(file);
-        String data = readFromInputStream(inputStream);
-
-        assertEquals(expectedData, data.trim());
-    }
-
-    @Test
-    public void givenFileNameAsAbsolutePath_whenUsingClasspath_thenFileData() throws IOException {
-        String expectedData = "Hello World from fileTest.txt!!!";
-
-        Class clazz = FileOperationsManualTest.class;
-        InputStream inputStream = clazz.getResourceAsStream("/fileTest.txt");
-        String data = readFromInputStream(inputStream);
-
-        assertEquals(expectedData, data.trim());
-    }
-
-    @Test
-    public void givenFileName_whenUsingJarFile_thenFileData() throws IOException {
-        String expectedData = "MIT License";
-
-        Class clazz = Matchers.class;
-        InputStream inputStream = clazz.getResourceAsStream("/LICENSE.txt");
-        String data = readFromInputStream(inputStream);
-
-        assertThat(data.trim(), CoreMatchers.containsString(expectedData));
-    }
-
-    @Test
-    public void givenURLName_whenUsingURL_thenFileData() throws IOException {
-        String expectedData = "Example Domain";
-
-        URL urlObject = new URL("http://www.example.com/");
-
-        URLConnection urlConnection = urlObject.openConnection();
-
-        InputStream inputStream = urlConnection.getInputStream();
-        String data = readFromInputStream(inputStream);
-
-        assertThat(data.trim(), CoreMatchers.containsString(expectedData));
-    }
-
-    @Test
-    public void givenFileName_whenUsingFileUtils_thenFileData() throws IOException {
-        String expectedData = "Hello World from fileTest.txt!!!";
-
-        ClassLoader classLoader = getClass().getClassLoader();
-        File file = new File(classLoader.getResource("fileTest.txt").getFile());
-        String data = FileUtils.readFileToString(file, "UTF-8");
-
-        assertEquals(expectedData, data.trim());
-    }
-
-    @Test
-    public void givenFilePath_whenUsingFilesReadAllBytes_thenFileData() throws IOException, URISyntaxException {
-        String expectedData = "Hello World from fileTest.txt!!!";
-
-        Path path = Paths.get(getClass().getClassLoader().getResource("fileTest.txt").toURI());
-
-        byte[] fileBytes = Files.readAllBytes(path);
-        String data = new String(fileBytes);
-
-        assertEquals(expectedData, data.trim());
-    }
-
-    @Test
-    public void givenFilePath_whenUsingFilesLines_thenFileData() throws IOException, URISyntaxException {
-        String expectedData = "Hello World from fileTest.txt!!!";
-
-        Path path = Paths.get(getClass().getClassLoader().getResource("fileTest.txt").toURI());
-
-        Stream<String> lines = Files.lines(path);
-        String data = lines.collect(Collectors.joining("\n"));
-        lines.close();
-
-        assertEquals(expectedData, data.trim());
-    }
-
-    private String readFromInputStream(InputStream inputStream) throws IOException {
-        StringBuilder resultStringBuilder = new StringBuilder();
-        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream))) {
-            String line;
-            while ((line = bufferedReader.readLine()) != null) {
-                resultStringBuilder.append(line).append("\n");
-            }
-        }
-
-        return resultStringBuilder.toString();
-    }
-    
-    @Test
-    public void givenFileName_whenUsingIOUtils_thenFileData() throws IOException {
-        String expectedData = "This is a content of the file";
-
-        FileInputStream fis = new FileInputStream("src/test/resources/fileToRead.txt");
-        String data = IOUtils.toString(fis, "UTF-8");
-        
-        assertEquals(expectedData, data.trim());
-    }
-}

core-java-modules/core-java-io/src/test/java/com/baeldung/readfile/JavaReadFromFileUnitTest.java

@@ -1,11 +1,15 @@
 package com.baeldung.readfile;
 
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matchers;
 import org.junit.Test;
-import org.junit.Ignore;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.io.*;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLConnection;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.charset.Charset;
@@ -13,55 +17,148 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Scanner;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 public class JavaReadFromFileUnitTest {
 
-    private static final Logger LOG = LoggerFactory.getLogger(JavaReadFromFileUnitTest.class);
-
     @Test
     public void whenReadWithBufferedReader_thenCorrect() throws IOException {
-        final String expected_value = "Hello world";
+        final String expected_value = "Hello, world!";
 
-        final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read.in"));
+        final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/fileTest.txt"));
         final String currentLine = reader.readLine();
         reader.close();
 
         assertEquals(expected_value, currentLine);
     }
 
+    @Test
+    public void givenFileName_whenUsingClassloader_thenFileData() throws IOException {
+        String expectedData = "Hello, world!";
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        File file = new File(classLoader.getResource("fileTest.txt").getFile());
+        InputStream inputStream = new FileInputStream(file);
+        String data = readFromInputStream(inputStream);
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFileNameAsAbsolutePath_whenUsingClasspath_thenFileData() throws IOException {
+        String expectedData = "Hello, world!";
+
+        Class clazz = JavaReadFromFileUnitTest.class;
+        InputStream inputStream = clazz.getResourceAsStream("/fileTest.txt");
+        String data = readFromInputStream(inputStream);
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFileName_whenUsingJarFile_thenFileData() throws IOException {
+        String expectedData = "BSD License";
+
+        Class clazz = Matchers.class;
+        InputStream inputStream = clazz.getResourceAsStream("/LICENSE.txt");
+        String data = readFromInputStream(inputStream);
+
+        assertThat(data.trim(), CoreMatchers.containsString(expectedData));
+    }
+
+    @Test
+    public void givenURLName_whenUsingURL_thenFileData() throws IOException {
+        String expectedData = "Example Domain";
+
+        URL urlObject = new URL("http://www.example.com/");
+
+        URLConnection urlConnection = urlObject.openConnection();
+
+        InputStream inputStream = urlConnection.getInputStream();
+        String data = readFromInputStream(inputStream);
+
+        assertThat(data.trim(), CoreMatchers.containsString(expectedData));
+    }
+
+    @Test
+    public void givenFileName_whenUsingFileUtils_thenFileData() throws IOException {
+        String expectedData = "Hello, world!";
+
+        ClassLoader classLoader = getClass().getClassLoader();
+        File file = new File(classLoader.getResource("fileTest.txt").getFile());
+        String data = FileUtils.readFileToString(file, "UTF-8");
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFilePath_whenUsingFilesReadAllBytes_thenFileData() throws IOException, URISyntaxException {
+        String expectedData = "Hello, world!";
+
+        Path path = Paths.get(getClass().getClassLoader().getResource("fileTest.txt").toURI());
+
+        byte[] fileBytes = Files.readAllBytes(path);
+        String data = new String(fileBytes);
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFilePath_whenUsingFilesLines_thenFileData() throws IOException, URISyntaxException {
+        String expectedData = "Hello, world!";
+
+        Path path = Paths.get(getClass().getClassLoader().getResource("fileTest.txt").toURI());
+
+        Stream<String> lines = Files.lines(path);
+        String data = lines.collect(Collectors.joining("\n"));
+        lines.close();
+
+        assertEquals(expectedData, data.trim());
+    }
+
+    @Test
+    public void givenFileName_whenUsingIOUtils_thenFileData() throws IOException {
+        String expectedData = "Hello, world!";
+
+        FileInputStream fis = new FileInputStream("src/test/resources/fileTest.txt");
+        String data = IOUtils.toString(fis, "UTF-8");
+
+        assertEquals(expectedData, data.trim());
+    }
+
     @Test
     public void whenReadWithScanner_thenCorrect() throws IOException {
-        final Scanner scanner = new Scanner(new File("src/test/resources/test_read1.in"));
+        final Scanner scanner = new Scanner(new File("src/test/resources/fileTest.txt"));
         scanner.useDelimiter(" ");
 
         assertTrue(scanner.hasNext());
-        assertEquals("Hello", scanner.next());
+        assertEquals("Hello,", scanner.next());
-        assertEquals("world", scanner.next());
+        assertEquals("world!", scanner.next());
-        assertEquals(1, scanner.nextInt());
 
         scanner.close();
-
     }
 
     @Test
     public void whenReadWithScannerTwoDelimiters_thenCorrect() throws IOException {
-        final Scanner scanner = new Scanner(new File("src/test/resources/test_read2.in"));
+        final Scanner scanner = new Scanner(new File("src/test/resources/fileTest.txt"));
-        scanner.useDelimiter(",| ");
+        scanner.useDelimiter("\\s|,");
 
-        assertTrue(scanner.hasNextInt());
+        assertTrue(scanner.hasNext());
-        assertEquals(2, scanner.nextInt());
+        assertEquals("Hello", scanner.next());
-        assertEquals(3, scanner.nextInt());
+        assertEquals("", scanner.next());
-        assertEquals(4, scanner.nextInt());
+        assertEquals("world!", scanner.next());
 
         scanner.close();
     }
 
     @Test
     public void whenReadWithStreamTokenizer_thenCorrectTokens() throws IOException {
-        final FileReader reader = new FileReader("src/test/resources/test_read3.in");
+        final FileReader reader = new FileReader("src/test/resources/fileTestTokenizer.txt");
         final StreamTokenizer tokenizer = new StreamTokenizer(reader);
 
         tokenizer.nextToken();
@@ -78,49 +175,36 @@ public class JavaReadFromFileUnitTest {
 
     @Test
     public void whenReadWithDataInputStream_thenCorrect() throws IOException {
-        final String expected_value = "Hello";
+        String expectedValue = "Hello, world!";
+        String file ="src/test/resources/fileTest.txt";
 
-        String result;
+        String result = null;
-        final DataInputStream reader = new DataInputStream(new FileInputStream("src/test/resources/test_read4.in"));
-        result = reader.readUTF();
-        reader.close();
 
-        assertEquals(expected_value, result);
+        DataInputStream reader = new DataInputStream(new FileInputStream(file));
-    }
+        int nBytesToRead = reader.available();
+        if(nBytesToRead > 0) {
+            byte[] bytes = new byte[nBytesToRead];
+            reader.read(bytes);
+            result = new String(bytes);
+        }
 
-    public void whenReadTwoFilesWithSequenceInputStream_thenCorrect() throws IOException {
+        assertEquals(expectedValue, result);
-        final int expected_value1 = 2000;
-        final int expected_value2 = 5000;
-
-        final FileInputStream stream1 = new FileInputStream("src/test/resources/test_read5.in");
-        final FileInputStream stream2 = new FileInputStream("src/test/resources/test_read6.in");
-
-        final SequenceInputStream sequence = new SequenceInputStream(stream1, stream2);
-        final DataInputStream reader = new DataInputStream(sequence);
-
-        assertEquals(expected_value1, reader.readInt());
-        assertEquals(expected_value2, reader.readInt());
-
-        reader.close();
-        stream2.close();
     }
 
     @Test
-    @Ignore // TODO
     public void whenReadUTFEncodedFile_thenCorrect() throws IOException {
         final String expected_value = "青空";
-        final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read7.in"), "UTF-8"));
+        final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/fileTestUtf8.txt"), "UTF-8"));
         final String currentLine = reader.readLine();
         reader.close();
-        LOG.debug(currentLine);
+
-        
         assertEquals(expected_value, currentLine);
     }
 
     @Test
     public void whenReadFileContentsIntoString_thenCorrect() throws IOException {
-        final String expected_value = "Hello world \n Test line \n";
+        final String expected_value = "Hello, world!\n";
-        final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read8.in"));
+        final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/fileTest.txt"));
         final StringBuilder builder = new StringBuilder();
         String currentLine = reader.readLine();
         while (currentLine != null) {
@@ -136,8 +220,8 @@ public class JavaReadFromFileUnitTest {
 
     @Test
     public void whenReadWithFileChannel_thenCorrect() throws IOException {
-        final String expected_value = "Hello world";
+        final String expected_value = "Hello, world!";
-        final RandomAccessFile reader = new RandomAccessFile("src/test/resources/test_read.in", "r");
+        final RandomAccessFile reader = new RandomAccessFile("src/test/resources/fileTest.txt", "r");
         final FileChannel channel = reader.getChannel();
 
         int bufferSize = 1024;
@@ -154,8 +238,8 @@ public class JavaReadFromFileUnitTest {
 
     @Test
     public void whenReadSmallFileJava7_thenCorrect() throws IOException {
-        final String expected_value = "Hello world";
+        final String expected_value = "Hello, world!";
-        final Path path = Paths.get("src/test/resources/test_read.in");
+        final Path path = Paths.get("src/test/resources/fileTest.txt");
 
         final String read = Files.readAllLines(path, Charset.defaultCharset()).get(0);
         assertEquals(expected_value, read);
@@ -163,12 +247,24 @@ public class JavaReadFromFileUnitTest {
 
     @Test
     public void whenReadLargeFileJava7_thenCorrect() throws IOException {
-        final String expected_value = "Hello world";
+        final String expected_value = "Hello, world!";
 
-        final Path path = Paths.get("src/test/resources/test_read.in");
+        final Path path = Paths.get("src/test/resources/fileTest.txt");
         final BufferedReader reader = Files.newBufferedReader(path, Charset.defaultCharset());
         final String line = reader.readLine();
         assertEquals(expected_value, line);
     }
 
+    private String readFromInputStream(InputStream inputStream) throws IOException {
+        StringBuilder resultStringBuilder = new StringBuilder();
+        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream))) {
+            String line;
+            while ((line = bufferedReader.readLine()) != null) {
+                resultStringBuilder.append(line).append("\n");
+            }
+        }
+
+        return resultStringBuilder.toString();
+    }
+
 }

core-java-modules/core-java-io/src/test/resources/fileTest.txt

@@ -1 +1 @@
-Hello World from fileTest.txt!!!
+Hello, world!

core-java-modules/core-java-io/src/test/resources/test_read1.in

@@ -1 +0,0 @@
-Hello world 1

core-java-modules/core-java-io/src/test/resources/test_read2.in

@@ -1 +0,0 @@
-2,3 4

core-java-modules/core-java-io/src/test/resources/test_read8.in

@@ -1,2 +0,0 @@
-Hello world 
- Test line 

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

@@ -99,7 +99,7 @@
                         <manifest>
                             <addClasspath>true</addClasspath>
                             <classpathPrefix>libs/</classpathPrefix>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                         </manifest>
                     </archive>
                 </configuration>
@@ -118,7 +118,7 @@
                             <archiveBaseDirectory>${project.basedir}</archiveBaseDirectory>
                             <archive>
                                 <manifest>
-                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                                    <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                                 </manifest>
                             </archive>
                             <descriptorRefs>
@@ -142,7 +142,7 @@
                             <shadedArtifactAttached>true</shadedArtifactAttached>
                             <transformers>
                                 <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                                    <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                                 </transformer>
                             </transformers>
                         </configuration>
@@ -157,7 +157,7 @@
                 <executions>
                     <execution>
                         <configuration>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                             <attachToBuild>true</attachToBuild>
                             <filename>${project.build.finalName}-onejar.${project.packaging}</filename>
                         </configuration>
@@ -179,7 +179,7 @@
                         </goals>
                         <configuration>
                             <classifier>spring-boot</classifier>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                         </configuration>
                     </execution>
                 </executions>

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

@@ -24,9 +24,14 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <version>5.5.1</version>
+            <version>${jupiter.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${jupiter.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-core</artifactId>

core-java-modules/core-java-jndi/src/test/java/com/baeldung/jndi/exceptions/JndiExceptionsUnitTest.java

@@ -17,7 +17,6 @@ import org.springframework.mock.jndi.SimpleNamingContextBuilder;
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 public class JndiExceptionsUnitTest {
 
-    @Disabled
     @Test
     @Order(1)
     void givenNoContext_whenLookupObject_thenThrowNoInitialContext() {

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

@@ -10,3 +10,5 @@ This module contains articles about working with the Java Virtual Machine (JVM).
 - [Class Loaders in Java](https://www.baeldung.com/java-classloaders)
 - [A Guide to System.exit()](https://www.baeldung.com/java-system-exit)
 - [Guide to System.gc()](https://www.baeldung.com/java-system-gc)
+- [Runtime.getRuntime().halt() vs System.exit() in Java](https://www.baeldung.com/java-runtime-halt-vs-system-exit)
+- [Adding Shutdown Hooks for JVM Applications](https://www.baeldung.com/jvm-shutdown-hooks)