Merge branch 'master' of https://github.com/eugenp/tutorials into BAEL_3301_testing_@ConfigurationProperties

.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-2/src/main/java/com/baeldung/algorithms/slope_one/SlopeOne.java

@@ -98,7 +98,7 @@ public class SlopeOne {
             for (Item j : InputData.items) {
                 if (e.getValue().containsKey(j)) {
                     clean.put(j, e.getValue().get(j));
-                } else {
+                } else if (!clean.containsKey(j)) {
                     clean.put(j, -1.0);
                 }
             }

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/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/balancedbrackets/BalancedBracketsUsingDeque.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+public class BalancedBracketsUsingDeque {
+
+    public boolean isBalanced(String str) {
+        if (null == str || ((str.length() % 2) != 0)) {
+            return false;
+        } else {
+            char[] ch = str.toCharArray();
+            for (char c : ch) {
+                if (!(c == '{' || c == '[' || c == '(' || c == '}' || c == ']' || c == ')')) {
+                    return false;
+                }
+
+            }
+        }
+
+        Deque<Character> deque = new LinkedList<>();
+        for (char ch : str.toCharArray()) {
+            if (ch == '{' || ch == '[' || ch == '(') {
+                deque.addFirst(ch);
+            } else {
+                if (!deque.isEmpty() && ((deque.peekFirst() == '{' && ch == '}') || (deque.peekFirst() == '[' && ch == ']') || (deque.peekFirst() == '(' && ch == ')'))) {
+                    deque.removeFirst();
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingString.java

@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+public class BalancedBracketsUsingString {
+
+    public boolean isBalanced(String str) {
+        if (null == str || ((str.length() % 2) != 0)) {
+            return false;
+        } else {
+            char[] ch = str.toCharArray();
+            for (char c : ch) {
+                if (!(c == '{' || c == '[' || c == '(' || c == '}' || c == ']' || c == ')')) {
+                    return false;
+                }
+
+            }
+        }
+
+        while (str.contains("()") || str.contains("[]") || str.contains("{}")) {
+            str = str.replaceAll("\\(\\)", "")
+                .replaceAll("\\[\\]", "")
+                .replaceAll("\\{\\}", "");
+        }
+        return (str.length() == 0);
+
+    }
+
+}

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/balancedbrackets/BalancedBracketsUsingDequeUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BalancedBracketsUsingDequeUnitTest {
+    private BalancedBracketsUsingDeque balancedBracketsUsingDeque;
+
+    @Before
+    public void setup() {
+        balancedBracketsUsingDeque = new BalancedBracketsUsingDeque();
+    }
+
+    @Test
+    public void givenNullInput_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced(null);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEmptyString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenInvalidCharacterString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("abc[](){}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenOddLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[]()}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[]()}}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthUnbalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{[(])}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{[()]}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[[(())]]}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenAnotherBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{([])}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenUnBalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{)[](}}");
+        assertThat(result).isFalse();
+    }
+
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingStringUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BalancedBracketsUsingStringUnitTest {
+    private BalancedBracketsUsingString balancedBracketsUsingString;
+
+    @Before
+    public void setup() {
+        balancedBracketsUsingString = new BalancedBracketsUsingString();
+    }
+
+    @Test
+    public void givenNullInput_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced(null);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEmptyString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenInvalidCharacterString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("abc[](){}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenOddLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[]()}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[]()}}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthUnbalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{[(])}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{[()]}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[[(())]]}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenAnotherBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{([])}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenUnBalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{)[](}}");
+        assertThat(result).isFalse();
+    }
+
+}

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-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)

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/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/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-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-3/src/main/java/com/baeldung/workstealing/PrimeNumbers.java

@@ -0,0 +1,85 @@
+package com.baeldung.workstealing;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.RecursiveAction;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class PrimeNumbers extends RecursiveAction {
+
+    private int lowerBound;
+    private int upperBound;
+    private int granularity;
+    static final List<Integer> GRANULARITIES
+      = Arrays.asList(1, 10, 100, 1000, 10000);
+    private AtomicInteger noOfPrimeNumbers;
+
+    PrimeNumbers(int lowerBound, int upperBound, int granularity, AtomicInteger noOfPrimeNumbers) {
+        this.lowerBound = lowerBound;
+        this.upperBound = upperBound;
+        this.granularity = granularity;
+        this.noOfPrimeNumbers = noOfPrimeNumbers;
+    }
+
+    PrimeNumbers(int upperBound) {
+        this(1, upperBound, 100, new AtomicInteger(0));
+    }
+
+    private PrimeNumbers(int lowerBound, int upperBound, AtomicInteger noOfPrimeNumbers) {
+        this(lowerBound, upperBound, 100, noOfPrimeNumbers);
+    }
+
+    private List<PrimeNumbers> subTasks() {
+        List<PrimeNumbers> subTasks = new ArrayList<>();
+
+        for (int i = 1; i <= this.upperBound / granularity; i++) {
+            int upper = i * granularity;
+            int lower = (upper - granularity) + 1;
+            subTasks.add(new PrimeNumbers(lower, upper, noOfPrimeNumbers));
+        }
+        return subTasks;
+    }
+
+    @Override
+    protected void compute() {
+        if (((upperBound + 1) - lowerBound) > granularity) {
+            ForkJoinTask.invokeAll(subTasks());
+        } else {
+            findPrimeNumbers();
+        }
+    }
+
+    void findPrimeNumbers() {
+        for (int num = lowerBound; num <= upperBound; num++) {
+            if (isPrime(num)) {
+                noOfPrimeNumbers.getAndIncrement();
+            }
+        }
+    }
+
+    private boolean isPrime(int number) {
+        if (number == 2) {
+            return true;
+        }
+
+        if (number == 1 || number % 2 == 0) {
+            return false;
+        }
+
+        int noOfNaturalNumbers = 0;
+
+        for (int i = 1; i <= number; i++) {
+            if (number % i == 0) {
+                noOfNaturalNumbers++;
+            }
+        }
+
+        return noOfNaturalNumbers == 2;
+    }
+
+    public int noOfPrimeNumbers() {
+        return noOfPrimeNumbers.intValue();
+    }
+}

core-java-modules/core-java-concurrency-advanced-3/src/test/java/com/baeldung/rejection/SaturationPolicyUnitTest.java

@@ -33,7 +33,7 @@ public class SaturationPolicyUnitTest {
     @Test
     public void givenAbortPolicy_WhenSaturated_ThenShouldThrowRejectedExecutionException() {
         executor = new ThreadPoolExecutor(1, 1, 0, MILLISECONDS, new SynchronousQueue<>(), new AbortPolicy());
-        executor.execute(() -> waitFor(100));
+        executor.execute(() -> waitFor(250));
 
         assertThatThrownBy(() -> executor.execute(() -> System.out.println("Will be rejected"))).isInstanceOf(RejectedExecutionException.class);
     }
@@ -42,13 +42,13 @@ public class SaturationPolicyUnitTest {
     @Test
     public void givenCallerRunsPolicy_WhenSaturated_ThenTheCallerThreadRunsTheTask() {
         executor = new ThreadPoolExecutor(1, 1, 0, MILLISECONDS, new SynchronousQueue<>(), new CallerRunsPolicy());
-        executor.execute(() -> waitFor(100));
+        executor.execute(() -> waitFor(250));
 
-        long startTime = System.nanoTime();
+        long startTime = System.currentTimeMillis();
-        executor.execute(() -> waitFor(100));
+        executor.execute(() -> waitFor(500));
-        double blockedDuration = (System.nanoTime() - startTime) / 1_000_000.0;
+        long blockedDuration = System.currentTimeMillis() - startTime;
 
-        assertThat(blockedDuration).isGreaterThanOrEqualTo(100);
+        assertThat(blockedDuration).isGreaterThanOrEqualTo(500);
     }
 
     @Test

core-java-modules/core-java-concurrency-advanced-3/src/test/java/com/baeldung/workstealing/PrimeNumbersUnitTest.java

@@ -0,0 +1,101 @@
+package com.baeldung.workstealing;
+
+import org.junit.Test;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Logger;
+
+import static org.junit.Assert.fail;
+
+public class PrimeNumbersUnitTest {
+
+    private static Logger logger = Logger.getAnonymousLogger();
+
+    @Test
+    public void givenPrimesCalculated_whenUsingPoolsAndOneThread_thenOneThreadSlowest() {
+        Options opt = new OptionsBuilder()
+          .include(Benchmarker.class.getSimpleName())
+          .forks(1)
+          .build();
+
+        try {
+            new Runner(opt).run();
+        } catch (RunnerException e) {
+            fail();
+        }
+    }
+
+    @Test
+    public void givenNewWorkStealingPool_whenGettingPrimes_thenStealCountChanges() {
+        StringBuilder info = new StringBuilder();
+
+        for (int granularity : PrimeNumbers.GRANULARITIES) {
+            int parallelism = ForkJoinPool.getCommonPoolParallelism();
+            ForkJoinPool pool =
+              (ForkJoinPool) Executors.newWorkStealingPool(parallelism);
+
+            stealCountInfo(info, granularity, pool);
+        }
+        logger.info("\nExecutors.newWorkStealingPool ->" + info.toString());
+    }
+
+    @Test
+    public void givenCommonPool_whenGettingPrimes_thenStealCountChangesSlowly() {
+        StringBuilder info = new StringBuilder();
+
+        for (int granularity : PrimeNumbers.GRANULARITIES) {
+            ForkJoinPool pool = ForkJoinPool.commonPool();
+            stealCountInfo(info, granularity, pool);
+        }
+        logger.info("\nForkJoinPool.commonPool ->" + info.toString());
+    }
+
+    private void stealCountInfo(StringBuilder info, int granularity, ForkJoinPool forkJoinPool) {
+        PrimeNumbers primes = new PrimeNumbers(1, 10000, granularity, new AtomicInteger(0));
+        forkJoinPool.invoke(primes);
+        forkJoinPool.shutdown();
+
+        long steals = forkJoinPool.getStealCount();
+        String output = "\nGranularity: [" + granularity + "], Steals: [" + steals + "]";
+        info.append(output);
+    }
+
+
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    @State(Scope.Benchmark)
+    @Fork(value = 2, warmups = 1, jvmArgs = {"-Xms2G", "-Xmx2G"})
+    public static class Benchmarker {
+
+        @Benchmark
+        public void singleThread() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            primes.findPrimeNumbers(); // get prime numbers using a single thread
+        }
+
+        @Benchmark
+        public void commonPoolBenchmark() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            ForkJoinPool pool = ForkJoinPool.commonPool();
+            pool.invoke(primes);
+            pool.shutdown();
+        }
+
+        @Benchmark
+        public void newWorkStealingPoolBenchmark() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            int parallelism = ForkJoinPool.getCommonPoolParallelism();
+            ForkJoinPool stealer = (ForkJoinPool) Executors.newWorkStealingPool(parallelism);
+            stealer.invoke(primes);
+            stealer.shutdown();
+        }
+    }
+}

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/pom.xml

@@ -13,12 +13,24 @@
 		<version>0.0.1-SNAPSHOT</version>
 		<relativePath>../../parent-java</relativePath>
 	</parent>
+	
+	<dependencies>
+		<!-- test scoped -->
+		<dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+	</dependencies>
 
 	<description> </description>
 	<url>http://maven.apache.org</url>
 
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<!-- testing -->
+		<assertj-core.version>3.10.0</assertj-core.version>
 	</properties>
 
 </project>

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

@@ -0,0 +1,28 @@
+package com.baeldung.exceptions;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.UnknownHostException;
+
+public class UnknownHostExceptionHandling {
+
+    public static int getResponseCode(String hostname) throws IOException {
+        URL url = new URL(hostname.trim());
+        HttpURLConnection con = (HttpURLConnection) url.openConnection();
+        int resCode = -1;
+        try {
+            resCode = con.getResponseCode();
+        } catch (UnknownHostException e){
+            con.disconnect();
+        }
+        return resCode;
+    }
+    
+    public static int getResponseCodeUnhandled(String hostname) throws IOException {
+        URL url = new URL(hostname.trim());
+        HttpURLConnection con = (HttpURLConnection) url.openConnection();
+        int resCode = con.getResponseCode();
+        return resCode;
+    }
+}

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/test/java/com/baeldung/exceptions/UnknownHostExceptionHandlingUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.exceptions;
+
+import java.io.IOException;
+import java.net.UnknownHostException;
+
+import org.junit.Test;
+
+public class UnknownHostExceptionHandlingUnitTest {
+
+    @Test(expected = UnknownHostException.class)
+    public void givenUnknownHost_whenResolve_thenUnknownHostException() throws IOException {
+        UnknownHostExceptionHandling.getResponseCodeUnhandled("http://locaihost");
+    }
+    
+}

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-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-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)

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

@@ -6,4 +6,7 @@ This module contains articles about core features in the Java language
 - [Java Primitives versus Objects](https://www.baeldung.com/java-primitives-vs-objects)
 - [Command-Line Arguments in Java](https://www.baeldung.com/java-command-line-arguments)
 - [What is a POJO Class?](https://www.baeldung.com/java-pojo-class)
+- [Java Default Parameters Using Method Overloading](https://www.baeldung.com/java-default-parameters-method-overloading)
+- [How to Return Multiple Values From a Java Method](https://www.baeldung.com/java-method-return-multiple-values)
+- [Guide to the Java finally Keyword](https://www.baeldung.com/java-finally-keyword)
 - [[<-- Prev]](/core-java-modules/core-java-lang)

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

@@ -15,6 +15,11 @@
     </parent>
 
     <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.9</version>
+        </dependency>
         <dependency>
             <groupId>commons-beanutils</groupId>
             <artifactId>commons-beanutils</artifactId>

core-java-modules/core-java-lang-2/src/main/java/com/baeldung/headlessmode/FlexibleApp.java

@@ -0,0 +1,27 @@
+package com.baeldung.headlessmode;
+
+import java.awt.GraphicsEnvironment;
+
+import javax.swing.JOptionPane;
+
+public class FlexibleApp {
+    public static final int HEADLESS = 0;
+    public static final int HEADED = 1;
+    public FlexibleApp() {
+
+        if (GraphicsEnvironment.isHeadless()) {
+            System.out.println("Hello World");
+        } else {
+            JOptionPane.showMessageDialog(null, "Hello World");
+        }
+
+    }
+    
+    public static int iAmFlexible() {
+        if (GraphicsEnvironment.isHeadless()) {
+            return HEADLESS;
+        } else {
+            return HEADED;
+        }
+    }
+}

core-java-modules/core-java-lang-2/src/main/java/com/baeldung/methodmultiplereturnvalues/MultipleReturnValuesUsingApacheCommonsPair.java

@@ -0,0 +1,20 @@
+package com.baeldung.methodmultiplereturnvalues;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.Comparator;
+import java.util.List;
+
+class MultipleReturnValuesUsingApacheCommonsPair {
+
+    static ImmutablePair<Coordinates, Double> getMostDistantPoint(
+      List<Coordinates> coordinatesList,
+      Coordinates target) {
+        return coordinatesList.stream()
+          .map(coordinates -> ImmutablePair.of(coordinates, coordinates.calculateDistance(target)))
+          .max(Comparator.comparingDouble(Pair::getRight))
+          .get();
+
+    }
+}

core-java-modules/core-java-lang-2/src/main/java/com/baeldung/methodmultiplereturnvalues/MultipleReturnValuesUsingApacheCommonsTriple.java

@@ -0,0 +1,23 @@
+package com.baeldung.methodmultiplereturnvalues;
+
+import org.apache.commons.lang3.tuple.ImmutableTriple;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+class MultipleReturnValuesUsingApacheCommonsTriple {
+
+    static ImmutableTriple<Double, Double, Double> getMinAvgMaxTriple(
+      List<Coordinates> coordinatesList,
+      Coordinates target) {
+
+        List<Double> distanceList = coordinatesList.stream()
+          .map(coordinates -> coordinates.calculateDistance(target))
+          .collect(Collectors.toList());
+        Double minDistance = distanceList.stream().mapToDouble(Double::doubleValue).min().getAsDouble();
+        Double avgDistance = distanceList.stream().mapToDouble(Double::doubleValue).average().orElse(0.0D);
+        Double maxDistance = distanceList.stream().mapToDouble(Double::doubleValue).max().getAsDouble();
+
+        return ImmutableTriple.of(minDistance, avgDistance, maxDistance);
+    }
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/headlessmode/HeadlessModeUnitTest.java

@@ -0,0 +1,87 @@
+package com.baeldung.headlessmode;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+import java.awt.Canvas;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Frame;
+import java.awt.GraphicsEnvironment;
+import java.awt.HeadlessException;
+import java.awt.image.BufferedImage;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.imageio.ImageIO;
+
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Test;
+
+public class HeadlessModeUnitTest {
+
+    private static final String IN_FILE = "/product.png";
+    private static final String OUT_FILE = System.getProperty("java.io.tmpdir") + "/product.jpg";
+    private static final String FORMAT = "jpg";
+
+    @Before
+    public void setUpHeadlessMode() {
+        System.setProperty("java.awt.headless", "true");
+    }
+
+    @Test
+    public void whenJavaAwtHeadlessSetToTrue_thenIsHeadlessReturnsTrue() {
+        assertThat(GraphicsEnvironment.isHeadless()).isTrue();
+    }
+
+    @Test
+    public void whenHeadlessMode_thenFontsWork() {
+        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+
+        String fonts[] = ge.getAvailableFontFamilyNames();
+
+        assertThat(fonts).isNotEmpty();
+
+        Font font = new Font(fonts[0], Font.BOLD, 14);
+
+        FontMetrics fm = (new Canvas()).getFontMetrics(font);
+
+        assertThat(fm.getHeight()).isGreaterThan(0);
+        assertThat(fm.getAscent()).isGreaterThan(0);
+        assertThat(fm.getDescent()).isGreaterThan(0);
+    }
+
+    @Test
+    public void whenHeadlessMode_thenImagesWork() throws IOException {
+        boolean result = false;
+        try (InputStream inStream = HeadlessModeUnitTest.class.getResourceAsStream(IN_FILE); FileOutputStream outStream = new FileOutputStream(OUT_FILE)) {
+            BufferedImage inputImage = ImageIO.read(inStream);
+            result = ImageIO.write(inputImage, FORMAT, outStream);
+        }
+
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void whenHeadlessmode_thenFrameThrowsHeadlessException() {
+        assertThatExceptionOfType(HeadlessException.class).isThrownBy(() -> {
+            Frame frame = new Frame();
+            frame.setVisible(true);
+            frame.setSize(120, 120);
+        });
+    }    
+
+    @Test
+    public void whenHeadless_thenFlexibleAppAdjustsItsBehavior() {
+        assertThat(FlexibleApp.iAmFlexible()).isEqualTo(FlexibleApp.HEADLESS);
+    }
+
+    @Test
+    public void whenHeaded_thenFlexibleAppAdjustsItsBehavior() {
+        Assume.assumeFalse(GraphicsEnvironment.isHeadless());
+        assertThat(FlexibleApp.iAmFlexible()).isEqualTo(FlexibleApp.HEADED);
+    }
+
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/methodmultiplereturnvalues/MultipleReturnValuesUsingApacheCommonsPairUnitTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.methodmultiplereturnvalues;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class MultipleReturnValuesUsingApacheCommonsPairUnitTest {
+
+    @Test
+    void whenUsingPair_thenMultipleFieldsAreReturned() {
+
+        List<Coordinates> coordinatesList = new ArrayList<>();
+        coordinatesList.add(new Coordinates(1, 1, "home"));
+        coordinatesList.add(new Coordinates(2, 2, "school"));
+        coordinatesList.add(new Coordinates(3, 3, "hotel"));
+
+        Coordinates target = new Coordinates(5, 5, "gym");
+
+        ImmutablePair<Coordinates, Double> mostDistantPoint = MultipleReturnValuesUsingApacheCommonsPair.getMostDistantPoint(coordinatesList, target);
+
+        assertEquals(1, mostDistantPoint.getLeft().getLongitude());
+        assertEquals(1, mostDistantPoint.getLeft().getLatitude());
+        assertEquals("home", mostDistantPoint.getLeft().getPlaceName());
+        assertEquals(5.66, BigDecimal.valueOf(mostDistantPoint.getRight()).setScale(2, RoundingMode.HALF_UP).doubleValue());
+
+    }
+
+}

core-java-modules/core-java-lang-2/src/test/java/com/baeldung/methodmultiplereturnvalues/MultipleReturnValuesUsingApacheCommonsTripleUnitTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.methodmultiplereturnvalues;
+
+import org.apache.commons.lang3.tuple.ImmutableTriple;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class MultipleReturnValuesUsingApacheCommonsTripleUnitTest {
+
+    @Test
+    void whenUsingTriple_thenMultipleFieldsAreReturned() {
+
+        List<Coordinates> coordinatesList = new ArrayList<>();
+        coordinatesList.add(new Coordinates(1, 1, "home"));
+        coordinatesList.add(new Coordinates(2, 2, "school"));
+        coordinatesList.add(new Coordinates(3, 3, "hotel"));
+
+        Coordinates target = new Coordinates(5, 5, "gym");
+
+        ImmutableTriple<Double, Double, Double> minAvgMax = MultipleReturnValuesUsingApacheCommonsTriple.getMinAvgMaxTriple(coordinatesList, target);
+
+        assertEquals(2.83, scaleDouble(minAvgMax.left));   //min
+        assertEquals(4.24, scaleDouble(minAvgMax.middle)); //avg
+        assertEquals(5.66, scaleDouble(minAvgMax.right));  //max
+    }
+
+    private double scaleDouble(Double d) {
+        return BigDecimal.valueOf(d).setScale(2, RoundingMode.HALF_UP).doubleValue();
+    }
+}

core-java-modules/core-java-lang-math/README.md

@@ -9,3 +9,4 @@
 - [The strictfp Keyword in Java](https://www.baeldung.com/java-strictfp)
 - [Basic Calculator in Java](https://www.baeldung.com/java-basic-calculator)
 - [Overflow and Underflow in Java](https://www.baeldung.com/java-overflow-underflow)
+- [Obtaining a Power Set of a Set in Java](https://www.baeldung.com/java-power-set-of-a-set)

core-java-modules/core-java-lang-oop-3/README.md

@@ -8,9 +8,9 @@ This module contains articles about Object-oriented programming (OOP) in Java
 - [Guide to the super Java Keyword](https://www.baeldung.com/java-super)
 - [Guide to the this Java Keyword](https://www.baeldung.com/java-this)
 - [Java ‘public’ Access Modifier](https://www.baeldung.com/java-public-keyword)
-- [Composition, Aggregation and Association in Java](https://www.baeldung.com/java-composition-aggregation-association)
+- [Composition, Aggregation, and Association in Java](https://www.baeldung.com/java-composition-aggregation-association)
 - [Nested Classes in Java](https://www.baeldung.com/java-nested-classes)
 - [A Guide to Inner Interfaces in Java](https://www.baeldung.com/java-inner-interfaces)
 - [Java Classes and Objects](https://www.baeldung.com/java-classes-objects)
 - [Java Interfaces](https://www.baeldung.com/java-interfaces)
-- [[<-- Prev]](/core-java-modules/core-java-lang-oop-2)[[More -->]](/core-java-modules/core-java-lang-oop-4)
+- [[<-- Prev]](/core-java-modules/core-java-lang-oop-2)[[More -->]](/core-java-modules/core-java-lang-oop-4)

core-java-modules/core-java-lang-oop/README.md

@@ -13,4 +13,5 @@ This module contains articles about Object-oriented programming (OOP) in Java
 - [The “final” Keyword in Java](https://www.baeldung.com/java-final)
 - [Type Erasure in Java Explained](https://www.baeldung.com/java-type-erasure)
 - [Variable and Method Hiding in Java](https://www.baeldung.com/java-variable-method-hiding)
+- [Object-Oriented-Programming Concepts in Java](https://www.baeldung.com/java-oop)
 - [[More -->]](/core-java-modules/core-java-lang-oop-2)

core-java-modules/core-java-lang-syntax-2/README.md

@@ -12,4 +12,5 @@ This module contains articles about Java syntax
 - [Variable Scope in Java](https://www.baeldung.com/java-variable-scope)
 - [Introduction to Basic Syntax in Java](https://www.baeldung.com/java-syntax)
 - [Java ‘protected’ Access Modifier](https://www.baeldung.com/java-protected-access-modifier)
+- [Using the Not Operator in If Conditions in Java](https://www.baeldung.com/java-using-not-in-if-conditions)
 - [[<-- Prev]](/core-java-modules/core-java-lang-syntax)

core-java-modules/core-java-lang-syntax/README.md

@@ -13,4 +13,7 @@ This module contains articles about Java syntax
 - [Infinite Loops in Java](https://www.baeldung.com/infinite-loops-java)
 - [Java Switch Statement](https://www.baeldung.com/java-switch)
 - [Breaking Out of Nested Loops](https://www.baeldung.com/java-breaking-out-nested-loop)
+- [Java Do-While Loop](https://www.baeldung.com/java-do-while-loop)
+- [Java While Loop](https://www.baeldung.com/java-while-loop)
+- [Java For Loop](https://www.baeldung.com/java-for-loop)
 - [[More -->]](/core-java-modules/core-java-lang-syntax-2)

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

@@ -9,3 +9,4 @@ This module contains articles about performance of Java applications
 - [OutOfMemoryError: GC Overhead Limit Exceeded](http://www.baeldung.com/java-gc-overhead-limit-exceeded)
 - [Basic Introduction to JMX](http://www.baeldung.com/java-management-extensions)
 - [Monitoring Java Applications with Flight Recorder](https://www.baeldung.com/java-flight-recorder-monitoring)
+- [Branch Prediction in Java](https://www.baeldung.com/java-branch-prediction)

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

@@ -6,4 +6,5 @@
 - [Guide to Java Reflection](http://www.baeldung.com/java-reflection)
 - [Call Methods at Runtime Using Java Reflection](http://www.baeldung.com/java-method-reflection)
 - [Changing Annotation Parameters At Runtime](http://www.baeldung.com/java-reflection-change-annotation-params)
-- [Dynamic Proxies in Java](http://www.baeldung.com/java-dynamic-proxies)
+- [Dynamic Proxies in Java](http://www.baeldung.com/java-dynamic-proxies)
+- [What Causes java.lang.reflect.InvocationTargetException?](https://www.baeldung.com/java-lang-reflect-invocationtargetexception)

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

@@ -0,0 +1,10 @@
+=========
+
+## Core Java 8 Cookbooks and Examples
+
+### Relevant Articles: 
+- [An Overview of Regular Expressions Performance in Java](https://www.baeldung.com/java-regex-performance)
+- [A Guide To Java Regular Expressions API](http://www.baeldung.com/regular-expressions-java)
+- [Guide to Escaping Characters in Java RegExps](http://www.baeldung.com/java-regexp-escape-char)
+- [Pre-compile Regex Patterns Into Pattern Objects](https://www.baeldung.com/java-regex-pre-compile)
+- [Difference Between Java Matcher find() and matches()](https://www.baeldung.com/java-matcher-find-vs-matches)

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

@@ -2,9 +2,9 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <artifactId>core-java-text</artifactId>
+    <artifactId>core-java-regex</artifactId>
     <version>0.1.0-SNAPSHOT</version>
-    <name>core-java-text</name>
+    <name>core-java-regex</name>
     <packaging>jar</packaging>
 
     <parent>
@@ -28,7 +28,7 @@
     </dependencies>
 
     <build>
-        <finalName>core-java-text</finalName>
+        <finalName>core-java-regex</finalName>
         <resources>
             <resource>
                 <directory>src/main/resources</directory>

core-java-modules/core-java-regex/src/test/java/com/baeldung/regex/RegexUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.java.regex;
+package com.baeldung.regex;
 
 import static org.junit.Assert.*;
 

core-java-modules/core-java-string-algorithms-3/README.md

@@ -3,3 +3,5 @@
 This module contains articles about string-related algorithms.
 
 ### Relevant Articles:
+
+- [Check if Two Strings are Anagrams in Java](https://www.baeldung.com/java-strings-anagrams)