Merge pull request #14 from eugenp/master

update

.gitignore

@@ -39,7 +39,6 @@ target/
 spring-openid/src/main/resources/application.properties
 .recommenders/
 /spring-hibernate4/nbproject/
-spring-security-openid/src/main/resources/application.properties
 
 spring-all/*.log
 

algorithms-miscellaneous-3/README.md

@@ -15,5 +15,4 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Creating a Triangle with for Loops in Java](https://www.baeldung.com/java-print-triangle)
 - [Efficient Word Frequency Calculator in Java](https://www.baeldung.com/java-word-frequency)
 - [The K-Means Clustering Algorithm in Java](https://www.baeldung.com/java-k-means-clustering-algorithm)
-- [Creating a Custom Annotation in Java](https://www.baeldung.com/java-custom-annotation)
 - More articles: [[<-- prev]](/algorithms-miscellaneous-2) [[next -->]](/algorithms-miscellaneous-4)

algorithms-miscellaneous-5/README.md

@@ -10,4 +10,6 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)
 - [Knapsack Problem Implementation in Java](https://www.baeldung.com/java-knapsack)
 - [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)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-4)

algorithms-miscellaneous-5/pom.xml

@@ -34,6 +34,11 @@
             <artifactId>tradukisto</artifactId>
             <version>${tradukisto.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>28.1-jre</version>
+        </dependency>
 
         <dependency>
             <groupId>org.assertj</groupId>

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/Follower.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.greedy;
+
+import lombok.Getter;
+
+public class Follower {
+
+    @Getter String username;
+    @Getter long count;
+    
+    public Follower(String username, long count) {
+        super();
+        this.username = username;
+        this.count = count;
+    }
+    
+    @Override
+    public String toString() {
+        return "User: " + username + ", Followers: " + count + "\n\r" ; 
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/FollowersPath.java

@@ -0,0 +1,44 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FollowersPath {
+
+    private List<Follower> accounts;
+    private long count;
+    
+    public FollowersPath() {
+        super();
+        this.accounts = new ArrayList<>();
+    }
+    
+    public List<Follower> getAccounts() {
+        return accounts;
+    }
+    public long getCount() {
+        return count;
+    }
+    
+    public void addFollower(String username, long count) {
+        accounts.add(new Follower(username, count));
+    }
+    
+    public void addCount(long count) {
+        this.count += count;
+    }
+    
+    @Override
+    public String toString() {
+        String details = "";
+        for(Follower a : accounts) {
+            details+=a.toString() + ", ";
+        }
+        
+        return "Total: " + count + ", \n\r" +
+                " Details: { " + "\n\r" + 
+                details + "\n\r" + 
+                " }";
+    }
+    
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/GreedyAlgorithm.java

@@ -0,0 +1,47 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.List;
+
+public class GreedyAlgorithm {
+
+    int currentLevel = 0;
+    final int maxLevel = 3; 
+    SocialConnector sc;
+    FollowersPath fp;
+    
+    public GreedyAlgorithm(SocialConnector sc) {
+        super();
+        this.sc = sc;
+        this.fp = new FollowersPath();
+    }
+    
+    public long findMostFollowersPath(String account) throws Exception {        
+        long max = 0;
+        SocialUser toFollow = null;
+        
+        List<SocialUser> followers = sc.getFollowers(account);
+        for (SocialUser el : followers) {
+            long followersCount = el.getFollowersCount();
+            if (followersCount > max) {
+                toFollow = el;
+                max = followersCount;
+            }
+        }
+        
+        if (currentLevel < maxLevel - 1) {
+            currentLevel++;
+            max += findMostFollowersPath(toFollow.getUsername());
+            //fp.addFollower(toFollow.getUsername(), max);
+            //fp.addCount(max);
+            return max;
+        } else {
+            //fp.addFollower(toFollow.getUsername(), max);
+            //fp.addCount(max);
+            return max;
+        }            
+    }
+    
+    public FollowersPath getFollowers() {
+        return fp;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/NonGreedyAlgorithm.java

@@ -0,0 +1,44 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.List;
+
+public class NonGreedyAlgorithm {
+
+    int currentLevel = 0;
+    final int maxLevel = 3; 
+    SocialConnector tc;
+    
+    public NonGreedyAlgorithm(SocialConnector tc, int level) {
+        super();
+        this.tc = tc;
+        this.currentLevel = level;
+    }
+    
+    
+    public long findMostFollowersPath(String account) throws Exception {        
+        List<SocialUser> followers = tc.getFollowers(account);
+        long total = currentLevel > 0 ? followers.size() : 0;
+
+        if (currentLevel < maxLevel ) {
+            currentLevel++;
+
+            long[] count = new long[followers.size()];
+            int i = 0;
+            for (SocialUser el : followers) {
+                NonGreedyAlgorithm sub = new NonGreedyAlgorithm(tc, currentLevel);
+                count[i] = sub.findMostFollowersPath(el.getUsername());
+                i++;
+            }
+            
+            long max = 0;
+            for (; i > 0; i--) {
+                if (count[i-1] > max )
+                    max = count[i-1];
+            }
+            
+            return total + max;
+        }
+        
+        return total;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/SocialConnector.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class SocialConnector {
+    private boolean isCounterEnabled = true;
+    private int counter = 4;
+    @Getter @Setter List<SocialUser> users;
+    
+    public SocialConnector() {
+        users = new ArrayList<>();
+    }
+    
+    public boolean switchCounter() {
+        this.isCounterEnabled = !this.isCounterEnabled;
+        return this.isCounterEnabled;
+    }
+    
+    public List<SocialUser> getFollowers(String account) throws Exception {
+        if (counter < 0)
+            throw new Exception ("API limit reached");
+        else {
+            if(this.isCounterEnabled) counter--;
+            for(SocialUser user : users) {
+                if (user.getUsername().equals(account)) {
+                    return user.getFollowers();
+                }
+            }
+        }
+        return new ArrayList<>();
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/SocialUser.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.Getter;
+
+public class SocialUser {
+
+    @Getter private String username;
+    @Getter private List<SocialUser> followers;
+
+    public SocialUser(String username) {
+        super();
+        this.username = username;
+        this.followers = new ArrayList<>();
+    }
+    
+    public SocialUser(String username, List<SocialUser> followers) {
+        super();
+        this.username = username;
+        this.followers = followers;
+    }
+    
+    public long getFollowersCount() {
+        return followers.size();
+    }
+    
+    public void addFollowers(List<SocialUser> followers) {
+        this.followers.addAll(followers);
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        return ((SocialUser) obj).getUsername().equals(username);
+    }
+    
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/integerstreammedian/MedianOfIntegerStream.java

@@ -0,0 +1,42 @@
+package com.baeldung.algorithms.integerstreammedian;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+import static java.util.Comparator.reverseOrder;
+
+public class MedianOfIntegerStream {
+
+    private Queue<Integer> minHeap, maxHeap;
+
+    MedianOfIntegerStream() {
+        minHeap = new PriorityQueue<>();
+        maxHeap = new PriorityQueue<>(reverseOrder());
+    }
+
+    void add(int num) {
+        if (!minHeap.isEmpty() && num < minHeap.peek()) {
+            maxHeap.offer(num);
+            if (maxHeap.size() > minHeap.size() + 1) {
+                minHeap.offer(maxHeap.poll());
+            }
+        } else {
+            minHeap.offer(num);
+            if (minHeap.size() > maxHeap.size() + 1) {
+                maxHeap.offer(minHeap.poll());
+            }
+        }
+    }
+
+    double getMedian() {
+        int median;
+        if (minHeap.size() < maxHeap.size()) {
+            median = maxHeap.peek();
+        } else if (minHeap.size() > maxHeap.size()) {
+            median = minHeap.peek();
+        } else {
+            median = (minHeap.peek() + maxHeap.peek()) / 2;
+        }
+        return median;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/integerstreammedian/MedianOfIntegerStream2.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.integerstreammedian;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+import static java.util.Comparator.reverseOrder;
+
+public class MedianOfIntegerStream2 {
+
+    private Queue<Integer> minHeap, maxHeap;
+
+    MedianOfIntegerStream2() {
+        minHeap = new PriorityQueue<>();
+        maxHeap = new PriorityQueue<>(reverseOrder());
+    }
+
+    void add(int num) {
+        if (minHeap.size() == maxHeap.size()) {
+            maxHeap.offer(num);
+            minHeap.offer(maxHeap.poll());
+        } else {
+            minHeap.offer(num);
+            maxHeap.offer(minHeap.poll());
+        }
+    }
+
+    double getMedian() {
+        int median;
+        if (minHeap.size() > maxHeap.size()) {
+            median = minHeap.peek();
+        } else {
+            median = (minHeap.peek() + maxHeap.peek()) / 2;
+        }
+        return median;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/kruskal/CycleDetector.java

@@ -0,0 +1,72 @@
+package com.baeldung.algorithms.kruskal;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CycleDetector {
+
+    List<DisjointSetInfo> nodes;
+
+    public CycleDetector(int totalNodes) {
+        initDisjointSets(totalNodes);
+    }
+
+    public boolean detectCycle(Integer u, Integer v) {
+        Integer rootU = pathCompressionFind(u);
+        Integer rootV = pathCompressionFind(v);
+        if (rootU.equals(rootV)) {
+            return true;
+        }
+        unionByRank(rootU, rootV);
+        return false;
+    }
+
+    private void initDisjointSets(int totalNodes) {
+        nodes = new ArrayList<>(totalNodes);
+        for (int i = 0; i < totalNodes; i++) {
+            nodes.add(new DisjointSetInfo(i));
+        }
+    }
+
+    private Integer find(Integer node) {
+        Integer parent = nodes.get(node).getParentNode();
+        if (parent.equals(node)) {
+            return node;
+        } else {
+            return find(parent);
+        }
+    }
+
+    private Integer pathCompressionFind(Integer node) {
+        DisjointSetInfo setInfo = nodes.get(node);
+        Integer parent = setInfo.getParentNode();
+        if (parent.equals(node)) {
+            return node;
+        } else {
+            Integer parentNode = find(parent);
+            setInfo.setParentNode(parentNode);
+            return parentNode;
+        }
+    }
+
+    private void union(Integer rootU, Integer rootV) {
+        DisjointSetInfo setInfoU = nodes.get(rootU);
+        setInfoU.setParentNode(rootV);
+    }
+
+    private void unionByRank(int rootU, int rootV) {
+        DisjointSetInfo setInfoU = nodes.get(rootU);
+        DisjointSetInfo setInfoV = nodes.get(rootV);
+        int rankU = setInfoU.getRank();
+        int rankV = setInfoV.getRank();
+        if (rankU < rankV) {
+            setInfoU.setParentNode(rootV);
+        } else {
+            setInfoV.setParentNode(rootU);
+            if (rankU == rankV) {
+                setInfoU.setRank(rankU + 1);
+            }
+        }
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/kruskal/DisjointSetInfo.java

@@ -0,0 +1,28 @@
+package com.baeldung.algorithms.kruskal;
+
+public class DisjointSetInfo {
+
+    private Integer parentNode;
+    private int rank;
+
+    DisjointSetInfo(Integer nodeNumber) {
+        setParentNode(nodeNumber);
+        setRank(1);
+    }
+
+    public Integer getParentNode() {
+        return parentNode;
+    }
+
+    public void setParentNode(Integer parentNode) {
+        this.parentNode = parentNode;
+    }
+
+    public int getRank() {
+        return rank;
+    }
+
+    public void setRank(int rank) {
+        this.rank = rank;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/kruskal/Kruskal.java

@@ -0,0 +1,53 @@
+package com.baeldung.algorithms.kruskal;
+
+import com.google.common.graph.EndpointPair;
+import com.google.common.graph.MutableValueGraph;
+import com.google.common.graph.ValueGraph;
+import com.google.common.graph.ValueGraphBuilder;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+
+public class Kruskal {
+
+    public ValueGraph<Integer, Double> minSpanningTree(ValueGraph<Integer, Double> graph) {
+
+        return spanningTree(graph, true);
+    }
+
+    public ValueGraph<Integer, Double> maxSpanningTree(ValueGraph<Integer, Double> graph) {
+        return spanningTree(graph, false);
+    }
+
+    private ValueGraph<Integer, Double> spanningTree(ValueGraph<Integer, Double> graph, boolean minSpanningTree) {
+        Set<EndpointPair<Integer>> edges = graph.edges();
+        List<EndpointPair<Integer>> edgeList = new ArrayList<>(edges);
+
+        if (minSpanningTree) {
+            edgeList.sort(Comparator.comparing(e -> graph.edgeValue(e).get()));
+        } else {
+            edgeList.sort(Collections.reverseOrder(Comparator.comparing(e -> graph.edgeValue(e).get())));
+        }
+
+        int totalNodes = graph.nodes().size();
+        CycleDetector cycleDetector = new CycleDetector(totalNodes);
+        int edgeCount = 0;
+
+        MutableValueGraph<Integer, Double> spanningTree = ValueGraphBuilder.undirected().build();
+        for (EndpointPair<Integer> edge : edgeList) {
+            if (cycleDetector.detectCycle(edge.nodeU(), edge.nodeV())) {
+                continue;
+            }
+            spanningTree.putEdgeValue(edge.nodeU(), edge.nodeV(), graph.edgeValue(edge).get());
+            edgeCount++;
+            if (edgeCount == totalNodes - 1) {
+                break;
+            }
+        }
+        return spanningTree;
+    }
+
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/greedy/GreedyAlgorithmUnitTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.algorithms.greedy;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class GreedyAlgorithmUnitTest {
+
+    private SocialConnector prepareNetwork() {
+        SocialConnector sc = new SocialConnector();
+        SocialUser root = new SocialUser("root");
+        SocialUser child1 = new SocialUser("child1");
+        SocialUser child2 = new SocialUser("child2");
+        SocialUser child3 = new SocialUser("child3");
+        SocialUser child21 = new SocialUser("child21");
+        SocialUser child211 = new SocialUser("child211");
+        SocialUser child2111 = new SocialUser("child2111");
+        SocialUser child31 = new SocialUser("child31");
+        SocialUser child311 = new SocialUser("child311");
+        SocialUser child3111 = new SocialUser("child3111");
+        child211.addFollowers(Arrays.asList(new SocialUser[]{child2111}));
+        child311.addFollowers(Arrays.asList(new SocialUser[]{child3111}));
+        child21.addFollowers(Arrays.asList(new SocialUser[]{child211}));
+        child31.addFollowers(Arrays.asList(new SocialUser[]{child311, 
+          new SocialUser("child312"), new SocialUser("child313"), new SocialUser("child314")}));
+        child1.addFollowers(Arrays.asList(new SocialUser[]{new SocialUser("child11"), new SocialUser("child12")}));
+        child2.addFollowers(Arrays.asList(new SocialUser[]{child21, new SocialUser("child22"), new SocialUser("child23")}));
+        child3.addFollowers(Arrays.asList(new SocialUser[]{child31}));
+        root.addFollowers(Arrays.asList(new SocialUser[]{child1, child2, child3}));
+        sc.setUsers(Arrays.asList(new SocialUser[]{root, child1, child2, child3, child21, child31, child311, child211}));
+        return sc;
+    }
+
+    @Test
+    public void greedyAlgorithmTest() throws Exception {
+        GreedyAlgorithm ga = new GreedyAlgorithm(prepareNetwork());
+        assertEquals(ga.findMostFollowersPath("root"), 5);
+    }
+
+    @Test
+    public void nongreedyAlgorithmTest() throws Exception {
+        NonGreedyAlgorithm nga = new NonGreedyAlgorithm(prepareNetwork(), 0);
+        Assertions.assertThrows(Exception.class, () -> {
+            nga.findMostFollowersPath("root");
+          });
+    }
+
+    @Test
+    public void nongreedyAlgorithmUnboundedTest() throws Exception {
+        SocialConnector sc = prepareNetwork();
+        sc.switchCounter();
+        NonGreedyAlgorithm nga = new NonGreedyAlgorithm(sc, 0);
+        assertEquals(nga.findMostFollowersPath("root"), 6);
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/integerstreammedian/MedianOfIntegerStreamUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.algorithms.integerstreammedian;
+
+import org.junit.Test;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class MedianOfIntegerStreamUnitTest {
+
+    @Test
+    public void givenStreamOfIntegers_whenAnElementIsRead_thenMedianChangesWithApproach1() {
+        MedianOfIntegerStream mis = new MedianOfIntegerStream();
+        for (Map.Entry<Integer, Double> e : testcaseFixture().entrySet()) {
+            mis.add(e.getKey());
+            assertEquals(e.getValue(), (Double) mis.getMedian());
+        }
+    }
+
+    @Test
+    public void givenStreamOfIntegers_whenAnElementIsRead_thenMedianChangesWithApproach2() {
+        MedianOfIntegerStream2 mis = new MedianOfIntegerStream2();
+        for (Map.Entry<Integer, Double> e : testcaseFixture().entrySet()) {
+            mis.add(e.getKey());
+            assertEquals(e.getValue(), (Double) mis.getMedian());
+        }
+    }
+
+    private Map<Integer, Double> testcaseFixture() {
+        return new LinkedHashMap<Integer, Double>() {{
+            put(1, 1d);
+            put(7, 4d);
+            put(5, 5d);
+            put(8, 6d);
+            put(3, 5d);
+            put(9, 6d);
+            put(4, 5d);
+        }};
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/kruskal/KruskalUnitTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.algorithms.kruskal;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import com.google.common.graph.MutableValueGraph;
+import com.google.common.graph.ValueGraph;
+import com.google.common.graph.ValueGraphBuilder;
+import com.baeldung.algorithms.kruskal.Kruskal;
+
+public class KruskalUnitTest {
+
+    private MutableValueGraph<Integer, Double> graph;
+
+    @Before
+    public void setup() {
+        graph = ValueGraphBuilder.undirected().build();
+        graph.putEdgeValue(0, 1, 8.0);
+        graph.putEdgeValue(0, 2, 5.0);
+        graph.putEdgeValue(1, 2, 9.0);
+        graph.putEdgeValue(1, 3, 11.0);
+        graph.putEdgeValue(2, 3, 15.0);
+        graph.putEdgeValue(2, 4, 10.0);
+        graph.putEdgeValue(3, 4, 7.0);
+    }
+
+    @Test
+    public void givenGraph_whenMinimumSpanningTree_thenOutputCorrectResult() {
+        final Kruskal kruskal = new Kruskal();
+        ValueGraph<Integer, Double> spanningTree = kruskal.minSpanningTree(graph);
+
+        assertTrue(spanningTree.hasEdgeConnecting(0, 1));
+        assertTrue(spanningTree.hasEdgeConnecting(0, 2));
+        assertTrue(spanningTree.hasEdgeConnecting(2, 4));
+        assertTrue(spanningTree.hasEdgeConnecting(3, 4));
+        assertEquals(graph.edgeValue(0, 1), spanningTree.edgeValue(0, 1));
+        assertEquals(graph.edgeValue(0, 2), spanningTree.edgeValue(0, 2));
+        assertEquals(graph.edgeValue(2, 4), spanningTree.edgeValue(2, 4));
+        assertEquals(graph.edgeValue(3, 4), spanningTree.edgeValue(3, 4));
+
+        assertFalse(spanningTree.hasEdgeConnecting(1, 2));
+        assertFalse(spanningTree.hasEdgeConnecting(1, 3));
+        assertFalse(spanningTree.hasEdgeConnecting(2, 3));
+    }
+
+    @Test
+    public void givenGraph_whenMaximumSpanningTree_thenOutputCorrectResult() {
+        final Kruskal kruskal = new Kruskal();
+        ValueGraph<Integer, Double> spanningTree = kruskal.maxSpanningTree(graph);
+
+        assertTrue(spanningTree.hasEdgeConnecting(0, 1));
+        assertTrue(spanningTree.hasEdgeConnecting(1, 3));
+        assertTrue(spanningTree.hasEdgeConnecting(2, 3));
+        assertTrue(spanningTree.hasEdgeConnecting(2, 4));
+        assertEquals(graph.edgeValue(0, 1), spanningTree.edgeValue(0, 1));
+        assertEquals(graph.edgeValue(1, 3), spanningTree.edgeValue(1, 3));
+        assertEquals(graph.edgeValue(2, 3), spanningTree.edgeValue(2, 3));
+        assertEquals(graph.edgeValue(2, 4), spanningTree.edgeValue(2, 4));
+
+        assertFalse(spanningTree.hasEdgeConnecting(0, 2));
+        assertFalse(spanningTree.hasEdgeConnecting(1, 2));
+        assertFalse(spanningTree.hasEdgeConnecting(3, 4));
+    }
+}

algorithms-searching/README.md

@@ -9,3 +9,4 @@ This module contains articles about searching algorithms.
 - [Breadth-First Search Algorithm in Java](https://www.baeldung.com/java-breadth-first-search)
 - [String Search Algorithms for Large Texts](https://www.baeldung.com/java-full-text-search-algorithms)
 - [Monte Carlo Tree Search for Tic-Tac-Toe Game](https://www.baeldung.com/java-monte-carlo-tree-search)
+- [Range Search Algorithm in Java](https://www.baeldung.com/java-range-search)

algorithms-searching/src/main/java/com/baeldung/algorithms/quadtree/Point.java

@@ -0,0 +1,24 @@
+package com.baeldung.algorithms.quadtree;
+
+public class Point {
+    private float x;
+    private float y;
+
+    public Point(float x, float y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public float getX() {
+        return x;
+    }
+
+    public float getY() {
+        return y;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + x + " , " + y + "]";
+    }
+}

algorithms-searching/src/main/java/com/baeldung/algorithms/quadtree/QuadTree.java

@@ -0,0 +1,109 @@
+package com.baeldung.algorithms.quadtree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class QuadTree {
+    private static final int MAX_POINTS = 3;
+    private Region area;
+    private List<Point> points = new ArrayList<>();
+    private List<QuadTree> quadTrees = new ArrayList<>();
+    private StringBuilder searchTraversePath;
+
+    public QuadTree(Region area) {
+        this.area = area;
+    }
+
+    public boolean addPoint(Point point) {
+        if (this.area.containsPoint(point)) {
+            if (this.points.size() < MAX_POINTS) {
+                this.points.add(point);
+                return true;
+            } else {
+                if (this.quadTrees.size() == 0) {
+                    createQuadrants();
+                }
+                return addPointToOneQuadrant(point);
+            }
+        }
+        return false;
+    }
+
+    private boolean addPointToOneQuadrant(Point point) {
+        boolean isPointAdded;
+        for (int i = 0; i < 4; i++) {
+            isPointAdded = this.quadTrees.get(i)
+                .addPoint(point);
+            if (isPointAdded)
+                return true;
+        }
+        return false;
+    }
+
+    private void createQuadrants() {
+        Region region;
+        for (int i = 0; i < 4; i++) {
+            region = this.area.getQuadrant(i);
+            quadTrees.add(new QuadTree(region));
+        }
+    }
+
+    public List<Point> search(Region searchRegion, List<Point> matches, String depthIndicator) {
+        searchTraversePath = new StringBuilder();
+        if (matches == null) {
+            matches = new ArrayList<Point>();
+            searchTraversePath.append(depthIndicator)
+                .append("Search Boundary =")
+                .append(searchRegion)
+                .append("\n");
+        }
+        if (!this.area.doesOverlap(searchRegion)) {
+            return matches;
+        } else {
+            for (Point point : points) {
+                if (searchRegion.containsPoint(point)) {
+                    searchTraversePath.append(depthIndicator)
+                    .append("Found match " + point)
+                    .append("\n");
+                    matches.add(point);
+                }
+            }
+            if (this.quadTrees.size() > 0) {
+                for (int i = 0; i < 4; i++) {
+                    searchTraversePath.append(depthIndicator)
+                        .append("Q")
+                        .append(i)
+                        .append("-->")
+                        .append(quadTrees.get(i).area)
+                        .append("\n");
+                    quadTrees.get(i)
+                        .search(searchRegion, matches, depthIndicator + "\t");
+                    this.searchTraversePath.append(quadTrees.get(i)
+                        .printSearchTraversePath());
+                }
+            }
+        }
+        return matches;
+    }
+
+    public String printTree(String depthIndicator) {
+        String str = "";
+        if (depthIndicator == "") {
+            str += "Root-->" + area.toString() + "\n";
+        }
+
+        for (Point point : points) {
+            str += depthIndicator + point.toString() + "\n";
+        }
+        for (int i = 0; i < quadTrees.size(); i++) {
+            str += depthIndicator + "Q" + String.valueOf(i) + "-->" + quadTrees.get(i).area.toString() + "\n";
+            str += quadTrees.get(i)
+                .printTree(depthIndicator + "\t");
+        }
+        return str;
+    }
+
+    public String printSearchTraversePath() {
+        return searchTraversePath.toString();
+    }
+}

algorithms-searching/src/main/java/com/baeldung/algorithms/quadtree/Region.java

@@ -0,0 +1,85 @@
+package com.baeldung.algorithms.quadtree;
+
+public class Region {
+    private float x1;
+    private float y1;
+    private float x2;
+    private float y2;
+
+    public Region(float x1, float y1, float x2, float y2) {
+        if (x1 >= x2 || y1 >= y2)
+            throw new IllegalArgumentException("(x1,y1) should be lesser than (x2,y2)");
+        this.x1 = x1;
+        this.y1 = y1;
+        this.x2 = x2;
+        this.y2 = y2;
+    }
+
+    public Region getQuadrant(int quadrantIndex) {
+        float quadrantWidth = (this.x2 - this.x1) / 2;
+        float quadrantHeight = (this.y2 - this.y1) / 2;
+
+        // 0=SW, 1=NW, 2=NE, 3=SE
+        switch (quadrantIndex) {
+        case 0:
+            return new Region(x1, y1, x1 + quadrantWidth, y1 + quadrantHeight);
+        case 1:
+            return new Region(x1, y1 + quadrantHeight, x1 + quadrantWidth, y2);
+        case 2:
+            return new Region(x1 + quadrantWidth, y1 + quadrantHeight, x2, y2);
+        case 3:
+            return new Region(x1 + quadrantWidth, y1, x2, y1 + quadrantHeight);
+        }
+        return null;
+    }
+
+    public boolean containsPoint(Point point) {
+        // Consider left and top side to be inclusive for points on border
+        return point.getX() >= this.x1 
+            && point.getX() < this.x2 
+            && point.getY() >= this.y1 
+            && point.getY() < this.y2;
+    }
+
+    public boolean doesOverlap(Region testRegion) {
+        // Is test region completely to left of my region?
+        if (testRegion.getX2() < this.getX1()) {
+            return false;
+        }
+        // Is test region completely to right of my region?
+        if (testRegion.getX1() > this.getX2()) {
+            return false;
+        }
+        // Is test region completely above my region?
+        if (testRegion.getY1() > this.getY2()) {
+            return false;
+        }
+        // Is test region completely below my region?
+        if (testRegion.getY2() < this.getY1()) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "[Region (x1=" + x1 + ", y1=" + y1 + "), (x2=" + x2 + ", y2=" + y2 + ")]";
+    }
+
+    public float getX1() {
+        return x1;
+    }
+
+    public float getY1() {
+        return y1;
+    }
+
+    public float getX2() {
+        return x2;
+    }
+
+    public float getY2() {
+        return y2;
+    }
+
+}

algorithms-searching/src/test/java/com/baeldung/algorithms/quadtree/QuadTreeSearchUnitTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.algorithms.quadtree;
+
+import org.junit.Assert;
+
+import java.util.List;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class QuadTreeSearchUnitTest {
+    
+    private static final Logger LOGGER = LoggerFactory.getLogger(QuadTreeSearchUnitTest.class);
+
+    private static QuadTree quadTree;
+
+    @BeforeClass
+    public static void setUp() {
+        Region area = new Region(0, 0, 400, 400);
+        quadTree = new QuadTree(area);
+
+        float[][] points = new float[][] { { 21, 25 }, { 55, 53 }, { 70, 318 }, { 98, 302 }, 
+            { 49, 229 }, { 135, 229 }, { 224, 292 }, { 206, 321 }, { 197, 258 }, { 245, 238 } };
+
+        for (int i = 0; i < points.length; i++) {
+            Point point = new Point(points[i][0], points[i][1]);
+            quadTree.addPoint(point);
+        }
+        LOGGER.info("\n" + quadTree.printTree(""));
+        LOGGER.info("==============================================");
+    }
+
+    @Test
+    public void givenQuadTree_whenSearchingForRange_thenReturn1MatchingItem() {
+        Region searchArea = new Region(200, 200, 250, 250);
+        List<Point> result = quadTree.search(searchArea, null, "");
+        LOGGER.info(result.toString());
+        LOGGER.info(quadTree.printSearchTraversePath());
+       
+        Assert.assertEquals(1, result.size());
+        Assert.assertArrayEquals(new float[] { 245, 238 }, 
+            new float[]{result.get(0).getX(), result.get(0).getY() }, 0);
+    }
+    
+    @Test
+    public void givenQuadTree_whenSearchingForRange_thenReturn2MatchingItems() {
+        Region searchArea = new Region(0, 0, 100, 100);
+        List<Point> result = quadTree.search(searchArea, null, "");
+        LOGGER.info(result.toString());
+        LOGGER.info(quadTree.printSearchTraversePath());
+        
+        Assert.assertEquals(2, result.size());
+        Assert.assertArrayEquals(new float[] { 21, 25 }, 
+            new float[]{result.get(0).getX(), result.get(0).getY() }, 0);
+        Assert.assertArrayEquals(new float[] { 55, 53 }, 
+            new float[]{result.get(1).getX(), result.get(1).getY() }, 0);
+        
+    }
+}

apache-fop/src/main/webapp/WEB-INF/web.xml

@@ -16,7 +16,7 @@
     </context-param>
     <context-param>
         <param-name>contextConfigLocation</param-name>
-        <param-value>org.baeldung.config</param-value>
+        <param-value>com.baeldung.config</param-value>
     </context-param>
 
     <listener>

apache-fop/src/test/java/com/baeldung/java/ApacheFOPConvertHTMLIntegrationTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java;
+package com.baeldung.java;
 
 import java.io.BufferedOutputStream;
 import java.io.File;

apache-fop/src/test/java/com/baeldung/java/ApacheFOPHeroldLiveTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java;
+package com.baeldung.java;
 
 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;

apache-olingo/olingo2/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <groupId>org.baeldung.examples.olingo2</groupId>
+    <groupId>com.baeldung.examples.olingo2</groupId>
     <artifactId>olingo2</artifactId>
     <name>olingo2</name>
     <description>Sample Olingo 2 Project</description>

apache-olingo/olingo2/src/main/java/com/baeldung/examples/olingo2/CarsODataJPAServiceFactory.java

@@ -1,4 +1,4 @@
-package org.baeldung.examples.olingo2;
+package com.baeldung.examples.olingo2;
 
 import java.util.List;
 import java.util.Map;
@@ -9,10 +9,8 @@ import javax.persistence.EntityManagerFactory;
 import javax.persistence.EntityTransaction;
 import javax.persistence.FlushModeType;
 import javax.persistence.LockModeType;
-import javax.persistence.Persistence;
 import javax.persistence.Query;
 import javax.persistence.StoredProcedureQuery;
-import javax.persistence.SynchronizationType;
 import javax.persistence.TypedQuery;
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.CriteriaDelete;
@@ -25,11 +23,8 @@ import org.apache.olingo.odata2.api.processor.ODataContext;
 import org.apache.olingo.odata2.jpa.processor.api.ODataJPAContext;
 import org.apache.olingo.odata2.jpa.processor.api.ODataJPAServiceFactory;
 import org.apache.olingo.odata2.jpa.processor.api.exception.ODataJPARuntimeException;
-import org.baeldung.examples.olingo2.JerseyConfig.EntityManagerFilter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.orm.jpa.EntityManagerFactoryUtils;
-import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
 import org.springframework.stereotype.Component;
 
 /**
@@ -58,7 +53,7 @@ public class CarsODataJPAServiceFactory extends ODataJPAServiceFactory {
         ODataJPAContext ctx = getODataJPAContext();
         ODataContext octx = ctx.getODataContext();
         HttpServletRequest request = (HttpServletRequest)octx.getParameter(ODataContext.HTTP_SERVLET_REQUEST_OBJECT);
-        EntityManager em = (EntityManager)request.getAttribute(EntityManagerFilter.EM_REQUEST_ATTRIBUTE);
+        EntityManager em = (EntityManager)request.getAttribute(JerseyConfig.EntityManagerFilter.EM_REQUEST_ATTRIBUTE);
                 
         // Here we're passing the EM that was created by the EntityManagerFilter (see JerseyConfig)
         ctx.setEntityManager(new EntityManagerWrapper(em));

apache-olingo/olingo2/src/main/java/com/baeldung/examples/olingo2/JerseyConfig.java

@@ -1,11 +1,10 @@
-    package org.baeldung.examples.olingo2;
+    package com.baeldung.examples.olingo2;
 
 import java.io.IOException;
 
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import javax.persistence.EntityTransaction;
-import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.ApplicationPath;
 import javax.ws.rs.Path;

apache-olingo/olingo2/src/main/java/com/baeldung/examples/olingo2/Olingo2SampleApplication.java

@@ -1,8 +1,7 @@
-package org.baeldung.examples.olingo2;
+package com.baeldung.examples.olingo2;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.boot.builder.SpringApplicationBuilder;
 import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
 
 @SpringBootApplication

apache-olingo/olingo2/src/main/java/com/baeldung/examples/olingo2/domain/CarMaker.java

@@ -1,4 +1,4 @@
-package org.baeldung.examples.olingo2.domain;
+package com.baeldung.examples.olingo2.domain;
 
 import java.util.List;
 

apache-olingo/olingo2/src/main/java/com/baeldung/examples/olingo2/domain/CarModel.java

@@ -1,4 +1,4 @@
-package org.baeldung.examples.olingo2.domain;
+package com.baeldung.examples.olingo2.domain;
 
 import javax.persistence.Entity;
 import javax.persistence.FetchType;

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

@@ -1,4 +1,4 @@
-package org.baeldung.examples.olingo2;
+package com.baeldung.examples.olingo2;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;

core-java-lambdas/README.md

@@ -1,2 +0,0 @@
-### Relevant Articles:
-- [Java 9 java.lang.Module API](https://www.baeldung.com/java-lambda-effectively-final-local-variables)

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

@@ -12,3 +12,4 @@ This module contains articles about Java 11 core features
 - [An Introduction to Epsilon GC: A No-Op Experimental Garbage Collector](https://www.baeldung.com/jvm-epsilon-gc-garbage-collector)
 - [Guide to jlink](https://www.baeldung.com/jlink)
 - [Negate a Predicate Method Reference with Java 11](https://www.baeldung.com/java-negate-predicate-method-reference)
+- [Benchmark JDK Collections vs Eclipse Collections](https://www.baeldung.com/jdk-collections-vs-eclipse-collections)

core-java-modules/core-java-11/src/test/java/com/baeldung/patternreuse/PatternJava11UnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.patternreuse;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class PatternJava11UnitTest {
+
+    @Test
+    public void givenPreCompiledPattern_whenCallAsMatchPredicate_thenReturnMatchPredicateToMatchesPattern() {
+        List<String> namesToValidate = Arrays.asList("Fabio Silva", "Fabio Luis Silva");
+        Pattern firstLastNamePreCompiledPattern = Pattern.compile("[a-zA-Z]{3,} [a-zA-Z]{3,}");
+
+        Predicate<String> patternAsMatchPredicate = firstLastNamePreCompiledPattern.asMatchPredicate();
+        List<String> validatedNames = namesToValidate.stream()
+                .filter(patternAsMatchPredicate)
+                .collect(Collectors.toList());
+
+        assertTrue(validatedNames.contains("Fabio Silva"));
+        assertFalse(validatedNames.contains("Fabio Luis Silva"));
+    }
+}

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

@@ -0,0 +1,185 @@
+package com.baeldung.arraysort;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+
+import java.util.Arrays;
+import java.util.Random;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+/**
+ * Time taken by JUnit test cases can be seen in JUnit Runner
+ * @author rchaudhary23
+ *
+ */
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class SortComparisonUnitTest {
+
+    private int[] sizeOfArrays = { 1000, 10000, 100000, 1000000 };
+
+    private int[] _1000_elements_array;
+    private int[] _10000_elements_array;
+    private int[] _100000_elements_array;
+    private int[] _1000000_elements_array;
+
+    @Before
+    public void setUp() throws Exception {
+
+        _1000_elements_array = new int[sizeOfArrays[0]];
+        _10000_elements_array = new int[sizeOfArrays[1]];
+        _100000_elements_array = new int[sizeOfArrays[2]];
+        _1000000_elements_array = new int[sizeOfArrays[3]];
+
+        Random random = new Random();
+        for (int i = 0; i < sizeOfArrays[0]; i++) {
+            _1000_elements_array[i] = random.nextInt(sizeOfArrays[0]) + random.nextInt(sizeOfArrays[0]);
+        }
+
+        for (int i = 0; i < sizeOfArrays[1]; i++) {
+            _10000_elements_array[i] = random.nextInt(sizeOfArrays[1]) + random.nextInt(sizeOfArrays[1]);
+        }
+
+        for (int i = 0; i < sizeOfArrays[2]; i++) {
+            _100000_elements_array[i] = random.nextInt(sizeOfArrays[2]) + random.nextInt(sizeOfArrays[2]);
+        }
+
+        for (int i = 0; i < sizeOfArrays[3]; i++) {
+            _1000000_elements_array[i] = random.nextInt(sizeOfArrays[3]) + random.nextInt(sizeOfArrays[3]);
+        }
+
+    }
+
+    @Test
+    public void givenArrayOfIntegers_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
+
+        int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
+        int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+
+        Arrays.sort(array);
+
+        assertArrayEquals(expected, array);
+
+    }
+
+    @Test
+    public void givenArrayOfIntegers_whenUsingArraysSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
+        int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
+        int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
+
+        Arrays.sort(array, 2, 8);
+
+        assertArrayEquals(expected, array);
+    }
+
+    @Test
+    public void givenArrayOfIntegers_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
+        int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+
+        Arrays.parallelSort(array);
+
+        assertArrayEquals(expected, array);
+    }
+
+    @Test
+    public void givenArrayOfIntegers_whenUsingArraysParallelSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
+        int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
+        int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
+
+        Arrays.parallelSort(array, 2, 8);
+
+        assertArrayEquals(expected, array);
+    }
+
+    @Test
+    public void givenIntegerArrayOf1000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] sequentialDataSet = Arrays.copyOf(_1000_elements_array, _1000_elements_array.length);
+        Arrays.sort(sequentialDataSet);
+
+        assertNotNull(sequentialDataSet);
+        assertNotSame(Arrays.copyOf(_1000_elements_array, _1000_elements_array.length), sequentialDataSet);
+
+    }
+
+    @Test
+    public void givenIntegerArrayOf1000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] parallelDataSet = Arrays.copyOf(_1000_elements_array, _1000_elements_array.length);
+        Arrays.parallelSort(parallelDataSet);
+
+        assertNotNull(parallelDataSet);
+        assertNotSame(Arrays.copyOf(_1000_elements_array, _1000_elements_array.length), parallelDataSet);
+
+    }
+
+    @Test
+    public void givenIntegerArrayOf10000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] sequentialDataSet = Arrays.copyOf(_10000_elements_array, _10000_elements_array.length);
+        Arrays.sort(sequentialDataSet);
+
+        assertNotNull(sequentialDataSet);
+        assertNotSame(Arrays.copyOf(_10000_elements_array, _10000_elements_array.length), sequentialDataSet);
+    }
+
+    @Test
+    public void givenIntegerArrayOf10000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] parallelDataSet = Arrays.copyOf(_10000_elements_array, _10000_elements_array.length);
+        Arrays.parallelSort(parallelDataSet);
+
+        assertNotNull(parallelDataSet);
+        assertNotSame(Arrays.copyOf(_10000_elements_array, _10000_elements_array.length), parallelDataSet);
+    }
+
+    @Test
+    public void givenIntegerArrayOf100000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] sequentialDataSet = Arrays.copyOf(_100000_elements_array, _100000_elements_array.length);
+        Arrays.sort(sequentialDataSet);
+
+        assertNotNull(sequentialDataSet);
+        assertNotSame(Arrays.copyOf(_100000_elements_array, _100000_elements_array.length), sequentialDataSet);
+    }
+
+    @Test
+    public void givenIntegerArrayOf100000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] parallelDataSet = Arrays.copyOf(_100000_elements_array, _100000_elements_array.length);
+        Arrays.parallelSort(parallelDataSet);
+
+        assertNotNull(parallelDataSet);
+        assertNotSame(Arrays.copyOf(_100000_elements_array, _100000_elements_array.length), parallelDataSet);
+    }
+
+    @Test
+    public void givenIntegerArrayOf1000000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] sequentialDataSet = Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length);
+        Arrays.sort(sequentialDataSet);
+
+        assertNotNull(sequentialDataSet);
+        assertNotSame(Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length), sequentialDataSet);
+    }
+
+    @Test
+    public void givenIntegerArrayOf1000000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
+        int[] parallelDataSet = Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length);
+        Arrays.parallelSort(parallelDataSet);
+
+        assertNotNull(parallelDataSet);
+        assertNotSame(Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length), parallelDataSet);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        sizeOfArrays = null;
+        _1000_elements_array = null;
+        _10000_elements_array = null;
+        _100000_elements_array = null;
+        _1000000_elements_array = null;
+    }
+}
+
+

core-java-modules/core-java-date-operations/src/main/java/com/baeldung/date/comparison/DateComparisonUtils.java

@@ -1,8 +1,10 @@
 package com.baeldung.date.comparison;
 
 import java.text.SimpleDateFormat;
+import java.time.Instant;
 import java.time.LocalDate;
 import java.time.ZoneId;
+import java.time.temporal.ChronoUnit;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.TimeZone;
@@ -23,6 +25,14 @@ public class DateComparisonUtils {
         return localDate1.isEqual(localDate2);
     }
 
+    public static boolean isSameDayUsingInstant(Date date1, Date date2) {
+        Instant instant1 = date1.toInstant()
+            .truncatedTo(ChronoUnit.DAYS);
+        Instant instant2 = date2.toInstant()
+            .truncatedTo(ChronoUnit.DAYS);
+        return instant1.equals(instant2);
+    }
+
     public static boolean isSameDayUsingSimpleDateFormat(Date date1, Date date2) {
         SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMdd");
         return fmt.format(date1)

core-java-modules/core-java-date-operations/src/test/java/com/baeldung/date/comparison/DateComparisonUtilsUnitTest.java

@@ -1,13 +1,13 @@
 package com.baeldung.date.comparison;
 
-import org.junit.Test;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.util.Date;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import org.junit.Test;
 
 public class DateComparisonUtilsUnitTest {
 
@@ -23,6 +23,7 @@ public class DateComparisonUtilsUnitTest {
     @Test
     public void givenDatesWithDifferentTime_whenIsSameDay_thenReturnsTrue() {
         assertTrue(DateComparisonUtils.isSameDayUsingLocalDate(day1Morning, day1Evening));
+        assertTrue(DateComparisonUtils.isSameDayUsingInstant(day1Morning, day1Evening));
         assertTrue(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Morning, day1Evening));
         assertTrue(DateComparisonUtils.isSameDayUsingCalendar(day1Morning, day1Evening));
         assertTrue(DateComparisonUtils.isSameDayUsingApacheCommons(day1Morning, day1Evening));
@@ -35,6 +36,9 @@ public class DateComparisonUtilsUnitTest {
         assertFalse(DateComparisonUtils.isSameDayUsingLocalDate(day1Morning, day2Morning));
         assertFalse(DateComparisonUtils.isSameDayUsingLocalDate(day1Evening, day2Morning));
 
+        assertFalse(DateComparisonUtils.isSameDayUsingInstant(day1Morning, day2Morning));
+        assertFalse(DateComparisonUtils.isSameDayUsingInstant(day1Evening, day2Morning));
+
         assertFalse(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Morning, day2Morning));
         assertFalse(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Evening, day2Morning));
 

core-java-modules/core-java-date-operations/src/test/java/com/baeldung/datetime/DateUtilsUnitTest.java

@@ -9,12 +9,6 @@ import static org.junit.Assert.assertEquals;
 
 public class DateUtilsUnitTest {
 
-    @Test
-    public void givenTimeMillis_thenDateIsReturned() {
-        Date now = DateUtils.getNow();
-        assertEquals(DateUtils.getDate(now.getTime()), now);
-    }
-
     @Test
     public void givenDateAndPattern_thenDateIsCorrectlyReturned() throws ParseException {
         long milliseconds = new Date(2020 - 1900, 0, 1).getTime();

core-java-modules/core-java-date-operations/src/test/java/com/baeldung/datetime/sql/DateUtilsUnitTest.java

@@ -9,11 +9,6 @@ import org.junit.Test;
 
 public class DateUtilsUnitTest {
 
-    @Test
-    public void givenCurrentDate_thenTodayIsReturned() {
-        assertEquals(DateUtils.getNow().toLocalDate(), LocalDate.now());
-    }
-
     @Test(expected = IllegalArgumentException.class)
     public void givenDateAsString_whenPatternIsNotRespected_thenExceptionIsThrown() {
         DateUtils.getDate("2020 01 01");

core-java-modules/core-java-date-operations/src/test/java/com/baeldung/datetime/sql/TimestampUtilsUnitTest.java

@@ -1,22 +1,13 @@
 package com.baeldung.datetime.sql;
 
-import static org.junit.Assert.assertEquals;
-
 import org.junit.Test;
 
-import com.baeldung.datetime.sql.TimestampUtils;
-
 import java.text.ParseException;
-import java.util.Date;
+
+import static org.junit.Assert.assertEquals;
 
 public class TimestampUtilsUnitTest {
 
-    @Test
-    public void givenCurrentTimestamp_thenNowIsReturned() {
-        assertEquals(TimestampUtils.getNow()
-            .getTime(), new Date().getTime());
-    }
-
     @Test(expected = IllegalArgumentException.class)
     public void givenTimestampAsString_whenPatternIsNotRespected_thenExceptionIsThrown() {
         TimestampUtils.getTimestamp("2020/01/01 10:11-12");

core-java-modules/core-java-date-operations/src/test/java/com/baeldung/jvmtimezone/ModifyDefaultTimezoneUnitTest.java

@@ -1,9 +1,8 @@
-package com.baeldung.timezone;
+package com.baeldung.jvmtimezone;
 
 import org.junit.Test;
 
 import java.util.Calendar;
-import java.util.Date;
 import java.util.TimeZone;
 
 import static org.junit.Assert.assertEquals;
@@ -13,9 +12,7 @@ public class ModifyDefaultTimezoneUnitTest {
     @Test
     public void givenDefaultTimezoneSet_thenDateTimezoneIsCorrect() {
         TimeZone.setDefault(TimeZone.getTimeZone("Portugal"));
-        Date date = new Date();
         Calendar calendar = Calendar.getInstance();
-        calendar.setTime(date);
         assertEquals(calendar.getTimeZone(), TimeZone.getTimeZone("Portugal"));
     }
 

core-java-modules/core-java-date-operations/src/test/java/com/baeldung/jvmtimezone/ModifyTimezonePropertyUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.timezone;
+package com.baeldung.jvmtimezone;
 
 import org.junit.After;
 import org.junit.Before;
@@ -14,7 +14,7 @@ public class ModifyTimezonePropertyUnitTest {
 
     @Before
     public void setup() {
-        System.setProperty("user.timezone", "IST");
+        System.setProperty("user.timezone", "Asia/Kolkata");
         TimeZone.setDefault(null);
     }
 
@@ -25,10 +25,8 @@ public class ModifyTimezonePropertyUnitTest {
 
     @Test
     public void givenTimezonePropertySet_thenDateTimezoneIsCorrect() {
-        Date date = new Date();
         Calendar calendar = Calendar.getInstance();
-        calendar.setTime(date);
-        assertEquals(calendar.getTimeZone(), TimeZone.getTimeZone("IST"));
+        assertEquals(calendar.getTimeZone(), TimeZone.getTimeZone("Asia/Kolkata"));
     }
 
 }

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

@@ -0,0 +1,38 @@
+package com.baeldung.exceptions;
+
+import java.util.Set;
+import java.util.UUID;
+
+public class CatchingThrowable  {
+
+    class CapacityException extends Exception {
+        CapacityException(String message) {
+            super(message);
+        }
+    }
+
+    class StorageAPI {
+
+        public void addIDsToStorage(int capacity, Set<String> storage) throws CapacityException {
+            if (capacity < 1) {
+                throw new CapacityException("Capacity of less than 1 is not allowed");
+            }
+            int count = 0;
+            while (count < capacity) {
+                storage.add(UUID.randomUUID().toString());
+                count++;
+            }
+        }
+
+        // other methods go here ...
+    }
+
+    public void add(StorageAPI api, int capacity, Set<String> storage) {
+        try {
+            api.addIDsToStorage(capacity, storage);
+        } catch (Throwable throwable) {
+            // do something here
+        }
+    }
+
+}

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

@@ -7,3 +7,5 @@
 - [Java 8 Unsigned Arithmetic Support](https://www.baeldung.com/java-unsigned-arithmetic)
 - [How to Separate Double into Integer and Decimal Parts](https://www.baeldung.com/java-separate-double-into-integer-decimal-parts)
 - [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)

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

@@ -11,4 +11,5 @@ This module contains articles about Java operators
 - [Java Compound Operators](https://www.baeldung.com/java-compound-operators)
 - [The XOR Operator in Java](https://www.baeldung.com/java-xor-operator)
 - [Java Bitwise Operators](https://www.baeldung.com/java-bitwise-operators)
+- [Bitwise & vs Logical && Operators](https://www.baeldung.com/bitwise-vs-logical-operators/)
 

core-java-modules/core-java-lang-operators/src/test/java/com/baeldung/andoperators/BitwiseAndLogicalANDOperatorsUnitTest.java

@@ -0,0 +1,71 @@
+package com.baeldung.andoperators;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.Assert.*;
+
+public class BitwiseAndLogicalANDOperatorsUnitTest {
+
+    @Test
+    public void givenTwoTrueBooleans_whenBitwiseAndOperator_thenTrue() {
+        boolean trueBool = true;
+        boolean anotherTrueBool = true;
+        boolean trueANDTrue = trueBool & anotherTrueBool;
+        assertTrue(trueANDTrue);
+    }
+
+    @Test
+    public void givenOneFalseAndOneTrueBooleans_whenBitwiseAndOperator_thenFalse() {
+        boolean trueBool = true;
+        boolean falseBool = false;
+        boolean trueANDFalse = trueBool & falseBool;
+        assertFalse(trueANDFalse);
+    }
+
+    @Test
+    public void givenTwoFalseBooleans_whenBitwiseAndOperator_thenFalse() {
+        boolean falseBool = false;
+        boolean anotherFalseBool = false;
+        boolean falseANDFalse = falseBool & anotherFalseBool;
+        assertFalse(falseANDFalse);
+    }
+
+    @Test
+    public void givenTwoIntegers_whenBitwiseAndOperator_thenNewDecimalNumber() {
+        int six = 6;
+        int five = 5;
+        int shouldBeFour = six & five;
+        assertEquals(4, shouldBeFour);
+    }
+
+    @Test
+    public void givenTwoTrueBooleans_whenLogicalAndOperator_thenTrue() {
+        boolean trueBool = true;
+        boolean anotherTrueBool = true;
+        boolean trueANDTrue = trueBool && anotherTrueBool;
+        assertTrue(trueANDTrue);
+    }
+
+    @Test
+    public void givenOneFalseAndOneTrueBooleans_whenLogicalAndOperator_thenFalse() {
+        boolean trueBool = true;
+        boolean falseBool = false;
+        boolean trueANDFalse = trueBool && falseBool;
+        assertFalse(trueANDFalse);
+    }
+
+    @Test
+    public void givenTwoFalseBooleans_whenLogicalAndOperator_thenFalse() {
+        boolean falseBool = false;
+        boolean anotherFalseBool = false;
+        boolean falseANDFalse = falseBool && anotherFalseBool;
+        assertFalse(falseANDFalse);
+    }
+
+    @Test
+    public void givenTwoFalseExpressions_whenLogicalAndOperator_thenShortCircuitFalse() {
+        boolean shortCircuitResult = (2<1) && (4<5);
+        assertFalse(shortCircuitResult);
+    }
+
+}

core-java-modules/core-java-lang-syntax-2/src/main/java/com/baeldung/core/operators/notoperator/NotOperator.java

@@ -0,0 +1,99 @@
+package com.baeldung.core.operators.notoperator;
+
+/**
+ * Examples used in the article `Using the Not Operator in If Conditions in Java`.
+ */
+public class NotOperator {
+
+    public static void ifElseStatementExample() {
+        boolean isValid = true;
+
+        if (isValid) {
+            System.out.println("Valid");
+        } else {
+            System.out.println("Invalid");
+        }
+    }
+
+    public static void checkIsValidIsFalseWithEmptyIfBlock() {
+        boolean isValid = true;
+
+        if (isValid) {
+
+        } else {
+            System.out.println("Invalid");
+        }
+    }
+
+    public static void checkIsValidIsFalseWithJustTheIfBlock() {
+        boolean isValid = true;
+
+        if (isValid == false) {
+            System.out.println("Invalid");
+        }
+    }
+
+    public static void checkIsValidIsFalseWithTheNotOperator() {
+        boolean isValid = true;
+
+        if (!isValid) {
+            System.out.println("Invalid");
+        }
+    }
+
+    public static void notOperatorWithBooleanValueAsOperand() {
+        System.out.println(!true);   // prints false
+        System.out.println(!false);  // prints true
+        System.out.println(!!false); // prints false
+    }
+
+    public static void applyNotOperatorToAnExpression_example1() {
+        int count = 2;
+
+        System.out.println(!(count > 2));  // prints true
+        System.out.println(!(count <= 2)); // prints false
+    }
+
+    public static void applyNotOperatorToAnExpression_LogicalOperators() {
+        boolean x = true;
+        boolean y = false;
+
+        System.out.println(!(x && y));  // prints true
+        System.out.println(!(x || y));  // prints false
+    }
+
+    public static void precedence_example() {
+        boolean x = true;
+        boolean y = false;
+
+        System.out.println(!x && y);   // prints false
+        System.out.println(!(x && y)); // prints true
+    }
+
+    public static void pitfalls_ComplexConditionsExample() {
+        int count = 9;
+        int total = 100;
+
+        if (!(count >= 10 || total >= 1000)) {
+            System.out.println("Some more work to do");
+        }
+    }
+
+    public static void pitfalls_simplifyComplexConditionsByReversingLogicExample() {
+        int count = 9;
+        int total = 100;
+
+        if (count < 10 && total < 1000) {
+            System.out.println("Some more work to do");
+        }
+    }
+
+    public static void exitEarlyExample() {
+        boolean isValid = false;
+
+        if(!isValid) {
+            throw new IllegalArgumentException("Invalid input");
+        }
+        // Code to execute when isValid == true goes here
+    }
+}

core-java-modules/core-java-perf/src/test/java/com/baeldung/branchprediction/CombiningUnitTest.java

@@ -0,0 +1,57 @@
+package com.baeldung.branchprediction;
+
+import java.util.stream.LongStream;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CombiningUnitTest {
+    private static final Logger LOG = LoggerFactory.getLogger(CombiningUnitTest.class);
+
+    public static final int TOP = 10000000;
+    public static final double FRACTION = 0.1;
+
+    @Test
+    public void combined() {
+        long[] first = LongStream.range(0, TOP)
+            .map(n -> Math.random() < FRACTION ? 0 : n)
+            .toArray();
+        long[] second = LongStream.range(0, TOP)
+            .map(n -> Math.random() < FRACTION ? 0 : n)
+            .toArray();
+
+        long count = 0;
+        long start = System.currentTimeMillis();
+        for (int i = 0; i < TOP; i++) {
+            if (first[i] * second[i] != 0) {
+                ++count;
+            }
+        }
+        long end = System.currentTimeMillis();
+
+        LOG.info("Counted {}/{} numbers using combined mode in {}ms", count, TOP, end - start);
+
+    }
+
+    @Test
+    public void separate() {
+        long[] first = LongStream.range(0, TOP)
+            .map(n -> Math.random() < FRACTION ? 0 : n)
+            .toArray();
+        long[] second = LongStream.range(0, TOP)
+            .map(n -> Math.random() < FRACTION ? 0 : n)
+            .toArray();
+
+        long count = 0;
+        long start = System.currentTimeMillis();
+        for (int i = 0; i < TOP; i++) {
+            if (first[i] != 0 && second[i] != 0) {
+                ++count;
+            }
+        }
+        long end = System.currentTimeMillis();
+
+        LOG.info("Counted {}/{} numbers using separate mode in {}ms", count, TOP, end - start);
+    }
+}

core-java-modules/core-java-perf/src/test/java/com/baeldung/branchprediction/IfUnitTest.java

@@ -0,0 +1,92 @@
+package com.baeldung.branchprediction;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class IfUnitTest {
+    private static final Logger LOG = LoggerFactory.getLogger(IfUnitTest.class);
+
+    public static final int TOP = 10000000;
+
+    @Test
+    public void majorBranchSorted() {
+        test(TOP, 0.9, false);
+    }
+
+    @Test
+    public void minorBranchSorted() {
+        test(TOP, 0.1, false);
+    }
+
+    @Test
+    public void equalBranchSorted() {
+        test(TOP, 0.5, false);
+    }
+
+    @Test
+    public void allBranchSorted() {
+        test(TOP, 1, false);
+    }
+
+    @Test
+    public void noneBranchSorted() {
+        test(TOP, 0, false);
+    }
+
+    @Test
+    public void majorBranchShuffled() {
+        test(TOP, 0.9, true);
+    }
+
+    @Test
+    public void minorBranchShuffled() {
+        test(TOP, 0.1, true);
+    }
+
+    @Test
+    public void equalBranchShuffled() {
+        test(TOP, 0.5, true);
+    }
+
+    @Test
+    public void allBranchShuffled() {
+        test(TOP, 1, true);
+    }
+
+    @Test
+    public void noneBranchShuffled() {
+        test(TOP, 0, true);
+    }
+
+    private void test(long top, double cutoffPercentage, boolean shuffle) {
+        List<Long> numbers = LongStream.range(0, top)
+            .boxed()
+            .collect(Collectors.toList());
+        if (shuffle) {
+            Collections.shuffle(numbers);
+        }
+
+        long cutoff = (long)(top * cutoffPercentage);
+        long low = 0;
+        long high = 0;
+
+        long start = System.currentTimeMillis();
+        for (Long number : numbers) {
+            if (number < cutoff) {
+                ++low;
+            } else {
+                ++high;
+            }
+        }
+        long end = System.currentTimeMillis();
+
+        LOG.info("Counted {}/{} {} numbers in {}ms", low, high, shuffle ? "shuffled" : "sorted", end - start);
+
+    }
+}

core-java-modules/core-java-perf/src/test/java/com/baeldung/branchprediction/SortingUnitTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.branchprediction;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SortingUnitTest {
+    private static final Logger LOG = LoggerFactory.getLogger(SortingUnitTest.class);
+    public static final int BIG = 10000000;
+    public static final int SMALL = 100000;
+
+    @Test
+    public void sortedBig() {
+        test(BIG, false);
+    }
+
+    @Test
+    public void shuffledBig() {
+        test(BIG, true);
+    }
+
+    @Test
+    public void sortedSmall() {
+        test(SMALL, false);
+    }
+
+    @Test
+    public void shuffledSmall() {
+        test(SMALL, true);
+    }
+
+    private void test(long top, boolean shuffle) {
+        List<Long> numbers = LongStream.range(0, top)
+            .boxed()
+            .collect(Collectors.toList());
+
+        if (shuffle) {
+            Collections.shuffle(numbers);
+        }
+
+        long cutoff = top / 2;
+        long count = 0;
+
+        long start = System.currentTimeMillis();
+        for (Long number : numbers) {
+            if (number < cutoff) {
+                ++count;
+            }
+        }
+        long end = System.currentTimeMillis();
+
+        LOG.info("Counted {}/{} {} numbers in {}ms",
+            count, top, shuffle ? "shuffled" : "sorted", end - start);
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/randomstrings/RandomStringsUnitTest.java

@@ -1,72 +1,103 @@
-package com.baeldung.randomstrings;
-
-import org.apache.commons.lang3.RandomStringUtils;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.nio.charset.Charset;
-import java.util.Random;
-
-public class RandomStringsUnitTest {
-
-    private static final Logger LOG = LoggerFactory.getLogger(RandomStringsUnitTest.class);
-
-    @Test
-    public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() {
-        final byte[] array = new byte[7]; // length is bounded by 7
-        new Random().nextBytes(array);
-        final String generatedString = new String(array, Charset.forName("UTF-8"));
-
-        LOG.debug(generatedString);
-    }
-
-    @Test
-    public void givenUsingPlainJava_whenGeneratingRandomStringBounded_thenCorrect() {
-        final int leftLimit = 97; // letter 'a'
-        final int rightLimit = 122; // letter 'z'
-        final int targetStringLength = 10;
-        final Random random = new Random();
-        final StringBuilder buffer = new StringBuilder(targetStringLength);
-
-        for (int i = 0; i < targetStringLength; i++) {
-            final int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1));
-            buffer.append((char) randomLimitedInt);
-        }
-        final String generatedString = buffer.toString();
-
-        LOG.debug(generatedString);
-    }
-
-    @Test
-    public void givenUsingApache_whenGeneratingRandomString_thenCorrect() {
-        final String generatedString = RandomStringUtils.random(10);
-
-        LOG.debug(generatedString);
-    }
-
-    @Test
-    public void givenUsingApache_whenGeneratingRandomAlphabeticString_thenCorrect() {
-        final String generatedString = RandomStringUtils.randomAlphabetic(10);
-
-        LOG.debug(generatedString);
-    }
-
-    @Test
-    public void givenUsingApache_whenGeneratingRandomAlphanumericString_thenCorrect() {
-        final String generatedString = RandomStringUtils.randomAlphanumeric(10);
-
-        LOG.debug(generatedString);
-    }
-
-    @Test
-    public void givenUsingApache_whenGeneratingRandomStringBounded_thenCorrect() {
-        final int length = 10;
-        final boolean useLetters = true;
-        final boolean useNumbers = false;
-        final String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);
-
-        LOG.debug(generatedString);
-    }
-
-}
+package com.baeldung.randomstrings;
+
+import org.apache.commons.lang3.RandomStringUtils;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.Charset;
+import java.util.Random;
+
+public class RandomStringsUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(RandomStringsUnitTest.class);
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() {
+        byte[] array = new byte[7]; // length is bounded by 7
+        new Random().nextBytes(array);
+        String generatedString = new String(array, Charset.forName("UTF-8"));
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingPlainJava_whenGeneratingRandomStringBounded_thenCorrect() {
+        int leftLimit = 97; // letter 'a'
+        int rightLimit = 122; // letter 'z'
+        int targetStringLength = 10;
+        Random random = new Random();
+        StringBuilder buffer = new StringBuilder(targetStringLength);
+
+        for (int i = 0; i < targetStringLength; i++) {
+            int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1));
+            buffer.append((char) randomLimitedInt);
+        }
+        String generatedString = buffer.toString();
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingJava8_whenGeneratingRandomAlphabeticString_thenCorrect() {
+        int leftLimit = 97; // letter 'a'
+        int rightLimit = 122; // letter 'z'
+        int targetStringLength = 10;
+        Random random = new Random();
+
+        String generatedString = random.ints(leftLimit, rightLimit + 1)
+            .limit(targetStringLength)
+            .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+            .toString();
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingJava8_whenGeneratingRandomAlphanumericString_thenCorrect() {
+        int leftLimit = 48; // numeral '0'
+        int rightLimit = 122; // letter 'z'
+        int targetStringLength = 10;
+        Random random = new Random();
+
+        String generatedString = random.ints(leftLimit, rightLimit + 1)
+            .filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
+            .limit(targetStringLength)
+            .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+            .toString();
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomString_thenCorrect() {
+        String generatedString = RandomStringUtils.random(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomAlphabeticString_thenCorrect() {
+        String generatedString = RandomStringUtils.randomAlphabetic(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomAlphanumericString_thenCorrect() {
+        String generatedString = RandomStringUtils.randomAlphanumeric(10);
+
+        LOG.debug(generatedString);
+    }
+
+    @Test
+    public void givenUsingApache_whenGeneratingRandomStringBounded_thenCorrect() {
+        int length = 10;
+        boolean useLetters = true;
+        boolean useNumbers = false;
+        String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);
+
+        LOG.debug(generatedString);
+    }
+
+}

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

@@ -14,6 +14,19 @@
         <relativePath>../../parent-java</relativePath>
     </parent>
 
+    <dependencies>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh-core.version}</version>
+        </dependency>
+    </dependencies>
+
     <build>
         <finalName>core-java-text</finalName>
         <resources>

core-java-modules/core-java-text/src/main/java/com/baeldung/patternreuse/PatternPerformanceComparison.java

@@ -0,0 +1,92 @@
+package com.baeldung.patternreuse;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+import org.openjdk.jmh.runner.RunnerException;
+
+import java.io.IOException;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Fork(value = 1, warmups = 1)
+@Warmup(iterations = 5)
+@State(Scope.Benchmark)
+public class PatternPerformanceComparison {
+
+    private static final String PATTERN = "\\d*[02468]";
+    private static List<String> values;
+
+    private static Matcher matcherFromPreCompiledPattern;
+    private static Pattern preCompiledPattern;
+
+    public static void main(String[] args) throws IOException, RunnerException {
+        org.openjdk.jmh.Main.main(args);
+    }
+
+    @Benchmark
+    public void matcherFromPreCompiledPatternResetMatches(Blackhole bh) {
+        //With pre-compiled pattern and reusing the matcher
+        // 1 Pattern object created
+        // 1 Matcher objects created
+        for (String value : values) {
+            bh.consume(matcherFromPreCompiledPattern.reset(value).matches());
+        }
+    }
+
+    @Benchmark
+    public void preCompiledPatternMatcherMatches(Blackhole bh) {
+        // With pre-compiled pattern
+        // 1         Pattern object created
+        // 5_000_000 Matcher objects created
+        for (String value : values) {
+            bh.consume(preCompiledPattern.matcher(value).matches());
+        }
+    }
+
+    @Benchmark
+    public void patternCompileMatcherMatches(Blackhole bh) {
+        // Above approach "Pattern.matches(PATTERN, value)" makes this internally
+        // 5_000_000 Pattern objects created
+        // 5_000_000 Matcher objects created
+        for (String value : values) {
+            bh.consume(Pattern.compile(PATTERN).matcher(value).matches());
+        }
+    }
+
+    @Benchmark
+    public void patternMatches(Blackhole bh) {
+        // Above approach "value.matches(PATTERN)" makes this internally
+        // 5_000_000 Pattern objects created
+        // 5_000_000 Matcher objects created
+        for (String value : values) {
+            bh.consume(Pattern.matches(PATTERN, value));
+        }
+    }
+
+    @Benchmark
+    public void stringMatchs(Blackhole bh) {
+        // 5_000_000 Pattern objects created
+        // 5_000_000 Matcher objects created
+        Instant start = Instant.now();
+        for (String value : values) {
+            bh.consume(value.matches(PATTERN));
+        }
+    }
+
+    @Setup()
+    public void setUp() {
+        preCompiledPattern = Pattern.compile(PATTERN);
+        matcherFromPreCompiledPattern = preCompiledPattern.matcher("");
+
+        values = new ArrayList<>();
+        for (int x = 1; x <= 5_000_000; x++) {
+            values.add(String.valueOf(x));
+        }
+    }
+}

core-java-modules/core-java-text/src/test/java/com/baeldung/patternreuse/PatternUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.patternreuse;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.*;
+
+public class PatternUnitTest {
+
+    private static final Pattern FIRST_LAST_NAME_PRE_COMPILED_PATTERN = Pattern.compile("[a-zA-Z]{3,} [a-zA-Z]{3,}");
+    private static final Pattern SPLIT_PRE_COMPILED_PATTERN = Pattern.compile("__");
+
+    @Test
+    public void givenPreCompiledPattern_whenCallMatcher_thenReturnAMatcherToMatches() {
+        Matcher matcherName1 = FIRST_LAST_NAME_PRE_COMPILED_PATTERN.matcher("Fabio Silva");
+        Matcher matcherName2 = FIRST_LAST_NAME_PRE_COMPILED_PATTERN.matcher("Mr. Silva");
+
+        boolean matchesName1 = matcherName1.matches();
+        boolean matchesName2 = matcherName2.matches();
+
+        assertTrue(matchesName1);
+        assertFalse(matchesName2);
+    }
+
+    @Test
+    public void givenPreCompiledPattern_whenCallAsPredicate_thenReturnPredicateToFindPatternInTheList() {
+        List<String> namesToValidate = Arrays.asList("Fabio Silva", "Mr. Silva");
+        Predicate<String> patternsAsPredicate = FIRST_LAST_NAME_PRE_COMPILED_PATTERN.asPredicate();
+
+        List<String> validNames = namesToValidate.stream()
+                .filter(patternsAsPredicate)
+                .collect(Collectors.toList());
+
+        assertEquals(1, validNames.size());
+        assertTrue(validNames.contains("Fabio Silva"));
+    }
+
+    @Test
+    public void givenPreCompiledPattern_whenCallSplit_thenReturnArrayWithValuesSplitByThePattern() {
+        String[] textSplit = SPLIT_PRE_COMPILED_PATTERN.split("My_Name__is__Fabio_Silva");
+
+        assertEquals("My_Name", textSplit[0]);
+        assertEquals("is", textSplit[1]);
+        assertEquals("Fabio_Silva", textSplit[2]);
+    }
+
+    @Test
+    public void givenPreCompiledPattern_whenCallSplitAsStream_thenReturnArraySplitByThePattern() {
+        Stream<String> textSplitAsStream = SPLIT_PRE_COMPILED_PATTERN.splitAsStream("My_Name__is__Fabio_Silva");
+        String[] textSplit = textSplitAsStream.toArray(String[]::new);
+
+        assertEquals("My_Name", textSplit[0]);
+        assertEquals("is", textSplit[1]);
+        assertEquals("Fabio_Silva", textSplit[2]);
+    }
+}

core-kotlin-2/README.md

@@ -4,11 +4,5 @@ This module contains articles about core Kotlin.
 
 ### Relevant articles:
 
-- [Void Type in Kotlin](https://www.baeldung.com/kotlin-void-type)
-- [How to use Kotlin Range Expressions](https://www.baeldung.com/kotlin-ranges)
-- [Creating a Kotlin Range Iterator on a Custom Object](https://www.baeldung.com/kotlin-custom-range-iterator)
 - [Kotlin Scope Functions](https://www.baeldung.com/kotlin-scope-functions)
-- [Kotlin Annotations](https://www.baeldung.com/kotlin-annotations)
-- [Split a List into Parts in Kotlin](https://www.baeldung.com/kotlin-split-list-into-parts)
-- [Finding an Element in a List Using Kotlin](https://www.baeldung.com/kotlin-finding-element-in-list)
 - More articles: [[<-- prev]](/core-kotlin)

core-kotlin-modules/core-kotlin-advanced/README.md

@@ -0,0 +1,11 @@
+## Core Kotlin Advanced
+
+This module contains articles about advanced topics in Kotlin.
+
+### Relevant articles:
+- [Building DSLs in Kotlin](https://www.baeldung.com/kotlin-dsl)
+- [Regular Expressions in Kotlin](https://www.baeldung.com/kotlin-regular-expressions)
+- [Idiomatic Logging in Kotlin](https://www.baeldung.com/kotlin-logging)
+- [Mapping of Data Objects in Kotlin](https://www.baeldung.com/kotlin-data-objects)
+- [Reflection with Kotlin](https://www.baeldung.com/kotlin-reflection)
+- [Kotlin Contracts](https://www.baeldung.com/kotlin-contracts)

core-kotlin-modules/core-kotlin-advanced/pom.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-kotlin-advanced</artifactId>
+    <name>core-kotlin-advanced</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-kotlin-modules</groupId>
+        <artifactId>core-kotlin-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-stdlib-jdk8</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-test</artifactId>
+            <version>${kotlin.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <kotlin.version>1.3.30</kotlin.version>
+        <assertj.version>3.10.0</assertj.version>
+    </properties>
+
+</project>

core-kotlin-modules/core-kotlin-advanced/src/main/kotlin/com/baeldung/datamapping/UserExtensions.kt

@@ -3,10 +3,10 @@ package com.baeldung.datamapping
 import kotlin.reflect.full.memberProperties
 
 fun User.toUserView() = UserView(
-  name = "$firstName $lastName",
-  address = "$street $houseNumber",
-  telephone = phone,
-  age = age
+        name = "$firstName $lastName",
+        address = "$street $houseNumber",
+        telephone = phone,
+        age = age
 )
 
 fun User.toUserViewReflection() = with(::UserView) {

core-kotlin-modules/core-kotlin-advanced/src/main/kotlin/com/baeldung/dsl/SqlDsl.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.dsl
+package com.baeldung.dsl
 
 abstract class Condition {
 

core-kotlin-modules/core-kotlin-advanced/src/main/kotlin/com/baeldung/logging/LoggerAsExtensionOnAny.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.logging
+package com.baeldung.logging
 
 import org.slf4j.Logger
 

core-kotlin-modules/core-kotlin-advanced/src/main/kotlin/com/baeldung/logging/LoggerAsExtensionOnMarkerInterface.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.logging
+package com.baeldung.logging
 
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory

core-kotlin-modules/core-kotlin-advanced/src/main/kotlin/com/baeldung/logging/LoggerAsProperty.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.logging
+package com.baeldung.logging
 
 open class LoggerAsProperty {
     private val logger = getLogger(javaClass)

core-kotlin-modules/core-kotlin-advanced/src/main/kotlin/com/baeldung/logging/LoggerAsPropertyDelegate.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.logging
+package com.baeldung.logging
 
 import org.slf4j.Logger
 import kotlin.properties.ReadOnlyProperty
@@ -43,5 +43,5 @@ fun main(args: Array<String>) {
 
 class LoggerDelegate<in R : Any> : ReadOnlyProperty<R, Logger> {
     override fun getValue(thisRef: R, property: KProperty<*>) =
-        getLogger(getClassForLogging(thisRef.javaClass))
+            getLogger(getClassForLogging(thisRef.javaClass))
 }

core-kotlin-modules/core-kotlin-advanced/src/main/kotlin/com/baeldung/logging/LoggerInCompanionObject.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.logging
+package com.baeldung.logging
 
 open class LoggerInCompanionObject {
     companion object {

core-kotlin-modules/core-kotlin-advanced/src/main/kotlin/com/baeldung/logging/Util.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.logging
+package com.baeldung.logging
 
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory

core-kotlin-modules/core-kotlin-advanced/src/test/kotlin/com/baeldung/dsl/SqlDslTest.kt

@@ -1,8 +1,7 @@
-package com.baeldung.kotlin.dsl
+package com.baeldung.dsl
 
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
-import java.lang.Exception
 
 class SqlDslTest {
 

core-kotlin-modules/core-kotlin-advanced/src/test/kotlin/com/baeldung/reflection/JavaReflectionTest.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.reflection
+package com.baeldung.reflection
 
 import org.junit.Ignore
 import org.junit.Test

core-kotlin-modules/core-kotlin-advanced/src/test/kotlin/com/baeldung/reflection/KClassTest.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.reflection
+package com.baeldung.reflection
 
 import org.junit.Assert
 import org.junit.Ignore

core-kotlin-modules/core-kotlin-advanced/src/test/kotlin/com/baeldung/reflection/KMethodTest.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin.reflection
+package com.baeldung.reflection
 
 import org.junit.Assert
 import org.junit.Test

core-kotlin-modules/core-kotlin-advanced/src/test/kotlin/com/baeldung/regex/RegexTest.kt

@@ -1,12 +1,7 @@
-package com.baeldung.kotlin.stdlib
+package com.baeldung.regex
 
 import org.junit.Test
-import java.beans.ExceptionListener
-import java.beans.XMLEncoder
-import java.io.*
-import java.lang.Exception
 import kotlin.test.*
-import kotlin.text.RegexOption.*
 
 class RegexTest {
 

core-kotlin-modules/core-kotlin-collections/README.md

@@ -0,0 +1,10 @@
+## Core Kotlin Collections
+
+This module contains articles about core Kotlin collections.
+
+### Relevant articles:
+- [Split a List Into Parts in Kotlin](https://www.baeldung.com/kotlin-split-list-into-parts)
+- [Finding an Element in a List Using Kotlin](https://www.baeldung.com/kotlin-finding-element-in-list)
+- [Overview of Kotlin Collections API](https://www.baeldung.com/kotlin-collections-api)
+- [Converting a List to Map in Kotlin](https://www.baeldung.com/kotlin-list-to-map)
+- [Filtering Kotlin Collections](https://www.baeldung.com/kotlin-filter-collection)

core-kotlin-modules/core-kotlin-collections/pom.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-kotlin-collections</artifactId>
+    <name>core-kotlin-collections</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-kotlin-modules</groupId>
+        <artifactId>core-kotlin-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-stdlib-jdk8</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-test</artifactId>
+            <version>${kotlin.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <kotlin.version>1.3.30</kotlin.version>
+        <commons-math3.version>3.6.1</commons-math3.version>
+        <assertj.version>3.10.0</assertj.version>
+    </properties>
+
+</project>

core-kotlin-modules/core-kotlin-collections/src/test/kotlin/com/baeldung/collections/CollectionsTest.kt

@@ -1,9 +1,9 @@
-package com.baeldung.kotlin
+package com.baeldung.collections
 
 import org.junit.Test
-import kotlin.test.assertTrue
-import kotlin.test.assertFalse
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 class CollectionsTest {
 
@@ -142,5 +142,5 @@ class CollectionsTest {
         val  finalResult = theList.fold( 1000, { oldResult, currentItem -> oldResult + (currentItem *currentItem)})
         print(finalResult)
         assertEquals(1091, finalResult)
-    }        
+    }
 }

core-kotlin-modules/core-kotlin-collections/src/test/kotlin/com/baeldung/findelement/FindAnElementInAListUnitTest.kt

@@ -1,11 +1,11 @@
-package com.baeldung.lists
+package com.baeldung.findelement
 
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
-class ListsUnitTest {
+class FindAnElementInAListUnitTest {
 
     var batmans: List<String> = listOf("Christian Bale", "Michael Keaton", "Ben Affleck", "George Clooney")
 

core-kotlin-modules/core-kotlin-collections/src/test/kotlin/com/baeldung/listtomap/ListToMapTest.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin
+package com.baeldung.listtomap
 
 import org.junit.Test
 import kotlin.test.assertTrue

core-kotlin-modules/core-kotlin-collections/src/test/kotlin/com/baeldung/listtomap/User.kt

@@ -1,3 +1,3 @@
-package com.baeldung.kotlin
+package com.baeldung.listtomap
 
 data class User(val name: String, val age: Int, val hobbies: List<String>)

core-kotlin-modules/core-kotlin-collections/src/test/kotlin/com/baeldung/splitlist/SplitListIntoPartsTest.kt

@@ -1,9 +1,9 @@
-package com.baeldung.lambda
+package com.baeldung.splitlist
 
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals
 
-class SplittingTest {
+class SplitListIntoPartsTest {
     private val evenList = listOf(0, "a", 1, "b", 2, "c");
 
     private val unevenList = listOf(0, "a", 1, "b", 2, "c", 3);

core-kotlin-modules/core-kotlin-concurrency/README.md

@@ -0,0 +1,7 @@
+## Core Kotlin Concurrency
+
+This module contains articles about concurrency in Kotlin.
+
+### Relevant articles:
+- [Threads vs Coroutines in Kotlin](https://www.baeldung.com/kotlin-threads-coroutines)
+- [Introduction to Kotlin Coroutines](https://www.baeldung.com/kotlin-coroutines)

core-kotlin-modules/core-kotlin-concurrency/pom.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-kotlin-concurrency</artifactId>
+    <name>core-kotlin-concurrency</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-kotlin-modules</groupId>
+        <artifactId>core-kotlin-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-stdlib-jdk8</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-test</artifactId>
+            <version>${kotlin.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <kotlin.version>1.3.30</kotlin.version>
+        <assertj.version>3.10.0</assertj.version>
+    </properties>
+
+</project>

core-kotlin-modules/core-kotlin-concurrency/src/main/kotlin/com/baeldung/threadsvscoroutines/SimpleRunnable.kt

@@ -1,4 +1,4 @@
-package com.baeldung.thread
+package com.baeldung.threadsvscoroutines
 
 class SimpleRunnable: Runnable {
 

core-kotlin-modules/core-kotlin-concurrency/src/main/kotlin/com/baeldung/threadsvscoroutines/SimpleThread.kt

@@ -1,4 +1,4 @@
-package com.baeldung.thread
+package com.baeldung.threadsvscoroutines
 
 class SimpleThread: Thread() {
 

core-kotlin-modules/core-kotlin-concurrency/src/test/kotlin/com/baeldung/coroutines/CoroutinesUnitTest.kt

@@ -1,4 +1,4 @@
-package com.baeldung.kotlin
+package com.baeldung.coroutines
 
 import kotlinx.coroutines.*
 import org.junit.Test

core-kotlin-modules/core-kotlin-concurrency/src/test/kotlin/com/baeldung/threadsvscoroutines/CoroutineUnitTest.kt

@@ -1,4 +1,4 @@
-package com.baeldung.thread
+package com.baeldung.threadsvscoroutines
 
 import kotlinx.coroutines.*
 import org.junit.jupiter.api.Test

core-kotlin-modules/core-kotlin-concurrency/src/test/kotlin/com/baeldung/threadsvscoroutines/ThreadUnitTest.kt

@@ -1,4 +1,4 @@
-package com.baeldung.thread
+package com.baeldung.threadsvscoroutines
 
 import org.junit.jupiter.api.Test
 import kotlin.concurrent.thread

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

@@ -0,0 +1,13 @@
+## Core Kotlin Lang
+
+This module contains articles about core features in the Kotlin language.
+
+### Relevant articles:
+- [Kotlin return, break, continue Keywords](https://www.baeldung.com/kotlin-return-break-continue)
+- [Infix Functions in Kotlin](https://www.baeldung.com/kotlin-infix-functions)
+- [Lambda Expressions in Kotlin](https://www.baeldung.com/kotlin-lambda-expressions)
+- [Creating Java static final Equivalents in Kotlin](https://www.baeldung.com/kotlin-java-static-final)
+- [Initializing Arrays in Kotlin](https://www.baeldung.com/kotlin-initialize-array)
+- [Lazy Initialization in Kotlin](https://www.baeldung.com/kotlin-lazy-initialization)
+- [Comprehensive Guide to Null Safety in Kotlin](https://www.baeldung.com/kotlin-null-safety)
+- [[<-- Prev]](/core-kotlin-modules/core-kotlin-lang)

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

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-kotlin-lang-2</artifactId>
+    <name>core-kotlin-lang-2</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.core-kotlin-modules</groupId>
+        <artifactId>core-kotlin-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+</project>