Merge pull request #2 from eugenp/master

Sync Merge with eugenp/tutorials master

.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
 

README.md

@@ -1,3 +1,4 @@
+**UPDATE**: The price of "Learn Spring Security OAuth" will permanently change on the 11th of December, along with the upcoming OAuth2 material: http://bit.ly/github-lss
 
 The Courses
 ==============================

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,43 @@
+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) {
+        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());
+            return max;
+        } else {
+            return max;
+        }            
+    }
+    
+    public FollowersPath getFollowers() {
+        return fp;
+    }
+}

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

@@ -0,0 +1,43 @@
+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) {
+        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) {
+        if (counter < 0)
+            throw new IllegalStateException ("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/main/java/com/baeldung/algorithms/maximumsubarray/BruteForceAlgorithm.java

@@ -0,0 +1,35 @@
+package com.baeldung.algorithms.maximumsubarray;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class BruteForceAlgorithm {
+
+    private Logger logger = LoggerFactory.getLogger(BruteForceAlgorithm.class.getName());
+
+    public int maxSubArray(int[] arr) {
+
+        int size = arr.length;
+        int maximumSubArraySum = Integer.MIN_VALUE;
+        int start = 0;
+        int end = 0;
+
+        for (int left = 0; left < size; left++) {
+
+            int runningWindowSum = 0;
+
+            for (int right = left; right < size; right++) {
+                runningWindowSum += arr[right];
+
+                if (runningWindowSum > maximumSubArraySum) {
+                    maximumSubArraySum = runningWindowSum;
+                    start = left;
+                    end = right;
+                }
+            }
+        }
+        logger.info("Found Maximum Subarray between {} and {}", start, end);
+        return maximumSubArraySum;
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/maximumsubarray/KadaneAlgorithm.java

@@ -0,0 +1,34 @@
+package com.baeldung.algorithms.maximumsubarray;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class KadaneAlgorithm {
+
+    private Logger logger = LoggerFactory.getLogger(BruteForceAlgorithm.class.getName());
+
+    public int maxSubArraySum(int[] arr) {
+
+        int size = arr.length;
+        int start = 0;
+        int end = 0;
+
+        int maxSoFar = 0, maxEndingHere = 0;
+
+        for (int i = 0; i < size; i++) {
+
+            if (arr[i] > maxEndingHere + arr[i]) {
+                start = i;
+                maxEndingHere = arr[i];
+            } else
+                maxEndingHere = maxEndingHere + arr[i];
+
+            if (maxSoFar < maxEndingHere) {
+                maxSoFar = maxEndingHere;
+                end = i;
+            }
+        }
+        logger.info("Found Maximum Subarray between {} and {}", start, end);
+        return maxSoFar;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/mergesortedarrays/SortedArrays.java

@@ -0,0 +1,33 @@
+package com.baeldung.algorithms.mergesortedarrays;
+
+public class SortedArrays {
+
+    public static int[] merge(int[] foo, int[] bar) {
+
+        int fooLength = foo.length;
+        int barLength = bar.length;
+
+        int[] merged = new int[fooLength + barLength];
+
+        int fooPosition, barPosition, mergedPosition;
+        fooPosition = barPosition = mergedPosition = 0;
+
+        while (fooPosition < fooLength && barPosition < barLength) {
+            if (foo[fooPosition] < bar[barPosition]) {
+                merged[mergedPosition++] = foo[fooPosition++];
+            } else {
+                merged[mergedPosition++] = bar[barPosition++];
+            }
+        }
+
+        while (fooPosition < fooLength) {
+            merged[mergedPosition++] = foo[fooPosition++];
+        }
+
+        while (barPosition < barLength) {
+            merged[mergedPosition++] = bar[barPosition++];
+        }
+
+        return merged;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/HeapNode.java

@@ -0,0 +1,13 @@
+package com.baeldung.algorithms.minheapmerge;
+
+public class HeapNode {
+
+    int element;
+    int arrayIndex;
+    int nextElementIndex = 1;
+
+    public HeapNode(int element, int arrayIndex) {
+        this.element = element;
+        this.arrayIndex = arrayIndex;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java

@@ -0,0 +1,88 @@
+package com.baeldung.algorithms.minheapmerge;
+
+public class MinHeap {
+
+    HeapNode[] heapNodes;
+
+    public MinHeap(HeapNode heapNodes[]) {
+        this.heapNodes = heapNodes;
+        heapifyFromLastLeafsParent();
+    }
+
+    void heapifyFromLastLeafsParent() {
+        int lastLeafsParentIndex = getParentNodeIndex(heapNodes.length);
+        while (lastLeafsParentIndex >= 0) {
+            heapify(lastLeafsParentIndex);
+            lastLeafsParentIndex--;
+        }
+    }
+
+    void heapify(int index) {
+        int leftNodeIndex = getLeftNodeIndex(index);
+        int rightNodeIndex = getRightNodeIndex(index);
+        int smallestElementIndex = index;
+        if (leftNodeIndex < heapNodes.length && heapNodes[leftNodeIndex].element < heapNodes[index].element) {
+            smallestElementIndex = leftNodeIndex;
+        }
+        if (rightNodeIndex < heapNodes.length && heapNodes[rightNodeIndex].element < heapNodes[smallestElementIndex].element) {
+            smallestElementIndex = rightNodeIndex;
+        }
+        if (smallestElementIndex != index) {
+            swap(index, smallestElementIndex);
+            heapify(smallestElementIndex);
+        }
+    }
+
+    int getParentNodeIndex(int index) {
+        return (index - 1) / 2;
+    }
+
+    int getLeftNodeIndex(int index) {
+        return (2 * index + 1);
+    }
+
+    int getRightNodeIndex(int index) {
+        return (2 * index + 2);
+    }
+
+    HeapNode getRootNode() {
+        return heapNodes[0];
+    }
+
+    void heapifyFromRoot() {
+        heapify(0);
+    }
+
+    void swap(int i, int j) {
+        HeapNode temp = heapNodes[i];
+        heapNodes[i] = heapNodes[j];
+        heapNodes[j] = temp;
+    }
+    
+    static int[] merge(int[][] array) {
+        HeapNode[] heapNodes = new HeapNode[array.length];
+        int resultingArraySize = 0;
+
+        for (int i = 0; i < array.length; i++) {
+            HeapNode node = new HeapNode(array[i][0], i);
+            heapNodes[i] = node;
+            resultingArraySize += array[i].length;
+        }
+        
+        MinHeap minHeap = new MinHeap(heapNodes);
+        int[] resultingArray = new int[resultingArraySize];
+
+        for (int i = 0; i < resultingArraySize; i++) {
+            HeapNode root = minHeap.getRootNode();
+            resultingArray[i] = root.element;
+
+            if (root.nextElementIndex < array[root.arrayIndex].length) {
+                root.element = array[root.arrayIndex][root.nextElementIndex++];
+            } else {
+                root.element = Integer.MAX_VALUE;
+            }
+            minHeap.heapifyFromRoot();
+        }
+        return resultingArray;
+    }
+}

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() {
+        GreedyAlgorithm ga = new GreedyAlgorithm(prepareNetwork());
+        assertEquals(ga.findMostFollowersPath("root"), 5);
+    }
+
+    @Test
+    public void nongreedyAlgorithmTest() {
+        NonGreedyAlgorithm nga = new NonGreedyAlgorithm(prepareNetwork(), 0);
+        Assertions.assertThrows(IllegalStateException.class, () -> {
+            nga.findMostFollowersPath("root");
+          });
+    }
+
+    @Test
+    public void nongreedyAlgorithmUnboundedTest() {
+        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-miscellaneous-5/src/test/java/com/baeldung/algorithms/maximumsubarray/BruteForceAlgorithmUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.algorithms.maximumsubarray;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class BruteForceAlgorithmUnitTest {
+
+    @Test
+    void givenArrayWithNegativeNumberWhenMaximumSubarrayThenReturns6() {
+        //given
+        int[] arr = new int[]{-3, 1, -8, 4, -1, 2, 1, -5, 5};
+        //when
+        BruteForceAlgorithm algorithm = new BruteForceAlgorithm();
+        int maximumSum = algorithm.maxSubArray(arr);
+        //then
+        assertEquals(6, maximumSum);
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/maximumsubarray/KadaneAlgorithmUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.algorithms.maximumsubarray;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class KadaneAlgorithmUnitTest {
+
+    @Test
+    void givenArrayWithNegativeNumberWhenMaximumSubarrayThenReturns6() {
+        //given
+        int[] arr = new int[]{-3, 1, -8, 4, -1, 2, 1, -5, 5};
+        //when
+        KadaneAlgorithm algorithm = new KadaneAlgorithm();
+        int maxSum = algorithm.maxSubArraySum(arr);
+        //then
+        assertEquals(6, maxSum);
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/mergesortedarrays/SortedArraysUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.mergesortedarrays;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.algorithms.mergesortedarrays.SortedArrays;
+
+public class SortedArraysUnitTest {
+
+    @Test
+    public void givenTwoSortedArrays_whenMerged_thenReturnMergedSortedArray() {
+
+        int[] foo = { 3, 7 };
+        int[] bar = { 4, 8, 11 };
+        int[] merged = { 3, 4, 7, 8, 11 };
+
+        assertArrayEquals(merged, SortedArrays.merge(foo, bar));
+    }
+
+    @Test
+    public void givenTwoSortedArraysWithDuplicates_whenMerged_thenReturnMergedSortedArray() {
+
+        int[] foo = { 3, 3, 7 };
+        int[] bar = { 4, 8, 8, 11 };
+        int[] merged = { 3, 3, 4, 7, 8, 8, 11 };
+
+        assertArrayEquals(merged, SortedArrays.merge(foo, bar));
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.algorithms.minheapmerge;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import org.junit.Test;
+
+public class MinHeapUnitTest {
+
+    private final int[][] inputArray = { { 0, 6 }, { 1, 5, 10, 100 }, { 2, 4, 200, 650 } };
+    private final int[] expectedArray = { 0, 1, 2, 4, 5, 6, 10, 100, 200, 650 };
+
+    @Test
+    public void givenSortedArrays_whenMerged_thenShouldReturnASingleSortedarray() {
+        int[] resultArray = MinHeap.merge(inputArray);
+        
+        assertThat(resultArray.length, is(equalTo(10)));
+        assertThat(resultArray, is(equalTo(expectedArray)));
+    }
+    
+}

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);
+        
+    }
+}

algorithms-sorting-2/.gitignore

@@ -0,0 +1,4 @@
+/target/
+.settings/
+.classpath
+.project

algorithms-sorting-2/pom.xml

@@ -0,0 +1,64 @@
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         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>algorithms-sorting-2</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-sorting-2</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit-jupiter-api.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${org.assertj.core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.codehaus.mojo</groupId>
+                    <artifactId>exec-maven-plugin</artifactId>
+                    <version>${exec-maven-plugin.version}</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+
+    <properties>
+        <commons-math3.version>3.6.1</commons-math3.version>
+        <org.assertj.core.version>3.9.0</org.assertj.core.version>
+        <commons-codec.version>1.11</commons-codec.version>
+        <junit-jupiter-api.version>5.3.1</junit-jupiter-api.version>
+    </properties>
+
+</project>

algorithms-sorting-2/src/main/java/com/baeldung/algorithms/quicksort/BentleyMcIlroyPartioning.java

@@ -0,0 +1,66 @@
+package com.baeldung.algorithms.quicksort;
+
+import static com.baeldung.algorithms.quicksort.SortingUtils.swap;
+
+public class BentleyMcIlroyPartioning {
+
+    public static Partition partition(int input[], int begin, int end) {
+        int left = begin, right = end;
+        int leftEqualKeysCount = 0, rightEqualKeysCount = 0;
+
+        int partitioningValue = input[end];
+
+        while (true) {
+            while (input[left] < partitioningValue)
+                left++;
+
+            while (input[right] > partitioningValue) {
+                if (right == begin)
+                    break;
+                right--;
+            }
+
+            if (left == right && input[left] == partitioningValue) {
+                swap(input, begin + leftEqualKeysCount, left);
+                leftEqualKeysCount++;
+                left++;
+            }
+
+            if (left >= right) {
+                break;
+            }
+
+            swap(input, left, right);
+
+            if (input[left] == partitioningValue) {
+                swap(input, begin + leftEqualKeysCount, left);
+                leftEqualKeysCount++;
+            }
+
+            if (input[right] == partitioningValue) {
+                swap(input, right, end - rightEqualKeysCount);
+                rightEqualKeysCount++;
+            }
+            left++; right--;
+        }
+        right = left - 1;
+        for (int k = begin; k < begin + leftEqualKeysCount; k++, right--) {
+            if (right >= begin + leftEqualKeysCount)
+                swap(input, k, right);
+        }
+        for (int k = end; k > end - rightEqualKeysCount; k--, left++) {
+            if (left <= end - rightEqualKeysCount)
+                swap(input, left, k);
+        }
+        return new Partition(right + 1, left - 1);
+    }
+
+    public static void quicksort(int input[], int begin, int end) {
+        if (end <= begin)
+            return;
+        Partition middlePartition = partition(input, begin, end);
+        quicksort(input, begin, middlePartition.getLeft() - 1);
+        quicksort(input, middlePartition.getRight() + 1, end);
+    }
+
+}

algorithms-sorting-2/src/main/java/com/baeldung/algorithms/quicksort/DutchNationalFlagPartioning.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.quicksort;
+
+import static com.baeldung.algorithms.quicksort.SortingUtils.compare;
+import static com.baeldung.algorithms.quicksort.SortingUtils.swap;
+
+public class DutchNationalFlagPartioning {
+
+    public static Partition partition(int[] a, int begin, int end) {
+        int lt = begin, current = begin, gt = end;
+        int partitioningValue = a[begin];
+
+        while (current <= gt) {
+            int compareCurrent = compare(a[current], partitioningValue);
+            switch (compareCurrent) {
+                case -1:
+                    swap(a, current++, lt++);
+                    break;
+                case 0:
+                    current++;
+                    break;
+                case 1:
+                    swap(a, current, gt--);
+                    break;
+            }
+        }
+        return new Partition(lt, gt);
+    }
+
+    public static void quicksort(int[] input, int begin, int end) {
+        if (end <= begin)
+            return;
+
+        Partition middlePartition = partition(input, begin, end);
+
+        quicksort(input, begin, middlePartition.getLeft() - 1);
+        quicksort(input, middlePartition.getRight() + 1, end);
+    }
+}

algorithms-sorting-2/src/main/java/com/baeldung/algorithms/quicksort/Partition.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.quicksort;
+
+public class Partition {
+    private int left;
+    private int right;
+
+    public Partition(int left, int right) {
+        super();
+        this.left = left;
+        this.right = right;
+    }
+
+    public int getLeft() {
+        return left;
+    }
+
+    public void setLeft(int left) {
+        this.left = left;
+    }
+
+    public int getRight() {
+        return right;
+    }
+
+    public void setRight(int right) {
+        this.right = right;
+    }
+
+}

algorithms-sorting-2/src/main/java/com/baeldung/algorithms/quicksort/SortingUtils.java

@@ -0,0 +1,32 @@
+package com.baeldung.algorithms.quicksort;
+
+public class SortingUtils {
+
+    public static void swap(int[] array, int position1, int position2) {
+        if (position1 != position2) {
+            int temp = array[position1];
+            array[position1] = array[position2];
+            array[position2] = temp;
+        }
+    }
+
+    public static int compare(int num1, int num2) {
+        if (num1 > num2)
+            return 1;
+        else if (num1 < num2)
+            return -1;
+        else
+            return 0;
+    }
+
+    public static void printArray(int[] array) {
+        if (array == null) {
+            return;
+        }
+        for (int e : array) {
+            System.out.print(e + " ");
+        }
+        System.out.println();
+    }
+
+}

algorithms-sorting-2/src/test/java/com/baeldung/algorithms/quicksort/BentleyMcilroyPartitioningUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung.algorithms.quicksort;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class BentleyMcilroyPartitioningUnitTest {
+
+    @Test
+    public void given_IntegerArray_whenSortedWithBentleyMcilroyPartitioning_thenGetSortedArray() {
+        int[] actual = {3, 2, 2, 2, 3, 7, 7, 3, 2, 2, 7, 3, 3};
+        int[] expected = {2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 7, 7, 7};
+        BentleyMcIlroyPartioning.quicksort(actual, 0, actual.length - 1);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+}

algorithms-sorting-2/src/test/java/com/baeldung/algorithms/quicksort/DNFThreeWayQuickSortUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.algorithms.quicksort;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DNFThreeWayQuickSortUnitTest {
+
+    @Test
+    public void givenIntegerArray_whenSortedWithThreeWayQuickSort_thenGetSortedArray() {
+        int[] actual = {3, 5, 5, 5, 3, 7, 7, 3, 5, 5, 7, 3, 3};
+        int[] expected = {3, 3, 3, 3, 3, 5, 5, 5, 5, 5, 7, 7, 7};
+        DutchNationalFlagPartioning.quicksort(actual, 0, actual.length - 1);
+        Assert.assertArrayEquals(expected, actual);
+    }
+}

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;

apache-poi/pom.xml

@@ -32,7 +32,7 @@
     </dependencies>
 
     <properties>
-        <poi.version>3.15</poi.version>
+        <poi.version>4.1.1</poi.version>
         <jexcel.version>1.0.6</jexcel.version>
     </properties>
 

apache-poi/src/main/java/com/baeldung/poi/excel/ExcelCellFormatter.java

@@ -0,0 +1,20 @@
+package com.baeldung.poi.excel;
+
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.DataFormatter;
+import org.apache.poi.ss.usermodel.FormulaEvaluator;
+import org.apache.poi.ss.usermodel.Workbook;
+
+public class ExcelCellFormatter {
+
+    public String getCellStringValue(Cell cell) {
+        DataFormatter formatter = new DataFormatter();
+        return formatter.formatCellValue(cell);
+    }
+
+    public String getCellStringValueWithFormula(Cell cell, Workbook workbook) {
+        DataFormatter formatter = new DataFormatter();
+        FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
+        return formatter.formatCellValue(cell, evaluator);
+    }
+}

apache-poi/src/main/java/com/baeldung/poi/excel/read/cellvalueandnotformula/CellValueAndNotFormulaHelper.java

@@ -0,0 +1,83 @@
+package com.baeldung.poi.excel.read.cellvalueandnotformula;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.ss.usermodel.FormulaEvaluator;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.util.CellAddress;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+
+public class CellValueAndNotFormulaHelper {
+
+    public Object getCellValueByFetchingLastCachedValue(String fileLocation, String cellLocation) throws IOException {
+        Object cellValue = new Object();
+
+        FileInputStream inputStream = new FileInputStream(new File(fileLocation));
+        Workbook workbook = new XSSFWorkbook(inputStream);
+
+        Sheet sheet = workbook.getSheetAt(0);
+
+        CellAddress cellAddress = new CellAddress(cellLocation);
+        Row row = sheet.getRow(cellAddress.getRow());
+        Cell cell = row.getCell(cellAddress.getColumn());
+
+        if (cell.getCellType() == CellType.FORMULA) {
+            switch (cell.getCachedFormulaResultType()) {
+                case BOOLEAN:
+                    cellValue = cell.getBooleanCellValue();
+                    break;
+                case NUMERIC:
+                    cellValue = cell.getNumericCellValue();
+                    break;
+                case STRING:
+                    cellValue = cell.getStringCellValue();
+                    break;
+                default:
+                    cellValue = null;
+            }
+        }
+
+        workbook.close();
+        return cellValue;
+    }
+
+    public Object getCellValueByEvaluatingFormula(String fileLocation, String cellLocation) throws IOException {
+        Object cellValue = new Object();
+
+        FileInputStream inputStream = new FileInputStream(new File(fileLocation));
+        Workbook workbook = new XSSFWorkbook(inputStream);
+
+        Sheet sheet = workbook.getSheetAt(0);
+        FormulaEvaluator evaluator = workbook.getCreationHelper()
+            .createFormulaEvaluator();
+
+        CellAddress cellAddress = new CellAddress(cellLocation);
+        Row row = sheet.getRow(cellAddress.getRow());
+        Cell cell = row.getCell(cellAddress.getColumn());
+
+        if (cell.getCellType() == CellType.FORMULA) {
+            switch (evaluator.evaluateFormulaCell(cell)) {
+                case BOOLEAN:
+                    cellValue = cell.getBooleanCellValue();
+                    break;
+                case NUMERIC:
+                    cellValue = cell.getNumericCellValue();
+                    break;
+                case STRING:
+                    cellValue = cell.getStringCellValue();
+                    break;
+                default:
+                    cellValue = null;
+            }
+        }
+
+        workbook.close();
+        return cellValue;
+    }
+}

apache-poi/src/test/java/com/baeldung/poi/excel/ExcelCellFormatterUnitTest.java

@@ -0,0 +1,87 @@
+package com.baeldung.poi.excel;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ExcelCellFormatterUnitTest {
+    private static final String FILE_NAME = "ExcelCellFormatterTest.xlsx";
+    private static final int STRING_CELL_INDEX = 0;
+    private static final int BOOLEAN_CELL_INDEX = 1;
+    private static final int RAW_NUMERIC_CELL_INDEX = 2;
+    private static final int FORMATTED_NUMERIC_CELL_INDEX = 3;
+    private static final int FORMULA_CELL_INDEX = 4;
+
+    private String fileLocation;
+
+    @Before
+    public void setup() throws IOException, URISyntaxException {
+            fileLocation = Paths.get(ClassLoader.getSystemResource(FILE_NAME).toURI()).toString();
+    }
+
+    @Test
+    public void givenStringCell_whenGetCellStringValue_thenReturnStringValue() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("String Test", formatter.getCellStringValue(row.getCell(STRING_CELL_INDEX)));
+        workbook.close();
+    }
+
+    @Test
+    public void givenBooleanCell_whenGetCellStringValue_thenReturnBooleanStringValue() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("TRUE", formatter.getCellStringValue(row.getCell(BOOLEAN_CELL_INDEX)));
+        workbook.close();
+    }
+
+    @Test
+    public void givenNumericCell_whenGetCellStringValue_thenReturnNumericStringValue() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("1.234", formatter.getCellStringValue(row.getCell(RAW_NUMERIC_CELL_INDEX)));
+        assertEquals("1.23", formatter.getCellStringValue(row.getCell(FORMATTED_NUMERIC_CELL_INDEX)));
+        workbook.close();
+    }
+
+    @Test
+    public void givenFormualCell_whenGetCellStringValue_thenReturnOriginalFormulaString() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("SUM(1+2)", formatter.getCellStringValue(row.getCell(FORMULA_CELL_INDEX)));
+        workbook.close();
+    }
+
+    @Test
+    public void givenFormualCell_whenGetCellStringValueForFormula_thenReturnOriginalFormulatring() throws IOException {
+        Workbook workbook = new XSSFWorkbook(fileLocation);
+        Sheet sheet = workbook.getSheetAt(0);
+        Row row = sheet.getRow(0);
+
+        ExcelCellFormatter formatter = new ExcelCellFormatter();
+        assertEquals("3", formatter.getCellStringValueWithFormula(row.getCell(FORMULA_CELL_INDEX), workbook));
+        workbook.close();
+    }
+
+}

apache-poi/src/test/java/com/baeldung/poi/excel/read/cellvalueandnotformula/CellValueAndNotFormulaUnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.poi.excel.read.cellvalueandnotformula;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class CellValueAndNotFormulaUnitTest {
+
+    private CellValueAndNotFormulaHelper readCellValueAndNotFormulaHelper;
+    private String fileLocation;
+    private static final String FILE_NAME = "test.xlsx";
+
+    @Before
+    public void setup() throws URISyntaxException {
+        fileLocation = Paths.get(ClassLoader.getSystemResource(FILE_NAME).toURI()).toString();
+        readCellValueAndNotFormulaHelper = new CellValueAndNotFormulaHelper();
+    }
+
+    @Test
+    public void givenExcelCell_whenReadCellValueByLastCachedValue_thenProduceCorrectResult() throws IOException {
+        final double expectedResult = 7.0;
+        final Object cellValue = readCellValueAndNotFormulaHelper.getCellValueByFetchingLastCachedValue(fileLocation, "C2");
+
+        assertEquals(expectedResult, cellValue);
+    }
+
+    @Test
+    public void givenExcelCell_whenReadCellValueByEvaluatingFormula_thenProduceCorrectResult() throws IOException {
+        final double expectedResult = 7.0;
+        final Object cellValue = readCellValueAndNotFormulaHelper.getCellValueByEvaluatingFormula(fileLocation, "C2");
+
+        assertEquals(expectedResult, cellValue);
+    }
+}

apache-rocketmq/README.md

@@ -0,0 +1,5 @@
+## Apache RocketMQ
+
+This module contains articles about Apache RocketMQ
+
+### Relevant Articles: 

apache-rocketmq/pom.xml

@@ -0,0 +1,27 @@
+<?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>apache-rocketmq</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <name>apache-rocketmq</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.rocketmq</groupId>
+            <artifactId>rocketmq-spring-boot-starter</artifactId>
+            <version>2.0.4</version>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <geode.core>1.6.0</geode.core>
+    </properties>
+</project>

apache-rocketmq/src/main/java/com/baeldung/rocketmq/consumer/CartEventConsumer.java

@@ -0,0 +1,34 @@
+package com.baeldung.rocketmq.consumer;
+
+import com.baeldung.rocketmq.event.CartItemEvent;
+import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
+import org.apache.rocketmq.spring.core.RocketMQListener;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.stereotype.Service;
+
+@SpringBootApplication
+public class CartEventConsumer {
+
+    public static void main(String[] args) {
+        SpringApplication.run(CartEventConsumer.class, args);
+    }
+
+    @Service
+    @RocketMQMessageListener(topic = "cart-item-add-topic", consumerGroup = "cart-consumer_cart-item-add-topic")
+    public class CardItemAddConsumer implements RocketMQListener<CartItemEvent> {
+        public void onMessage(CartItemEvent addItemEvent) {
+            System.out.println("Adding item: " + addItemEvent);
+            // logic
+        }
+    }
+
+    @Service
+    @RocketMQMessageListener(topic = "cart-item-removed-topic", consumerGroup = "cart-consumer_cart-item-removed-topic")
+    public class CardItemRemoveConsumer implements RocketMQListener<CartItemEvent> {
+        public void onMessage(CartItemEvent removeItemEvent) {
+            System.out.println("Removing item: " + removeItemEvent);
+            // logic
+        }
+    }
+}

apache-rocketmq/src/main/java/com/baeldung/rocketmq/event/CartItemEvent.java

@@ -0,0 +1,32 @@
+package com.baeldung.rocketmq.event;
+
+public class CartItemEvent {
+    private String itemId;
+    private int quantity;
+
+    public CartItemEvent(String itemId, int quantity) {
+        this.itemId = itemId;
+        this.quantity = quantity;
+    }
+
+    public String getItemId() {
+        return itemId;
+    }
+
+    public void setItemId(String itemId) {
+        this.itemId = itemId;
+    }
+
+    public int getQuantity() {
+        return quantity;
+    }
+
+    public void setQuantity(int quantity) {
+        this.quantity = quantity;
+    }
+
+    @Override
+    public String toString() {
+        return "CartItemEvent{" + "itemId='" + itemId + '\'' + ", quantity=" + quantity + '}';
+    }
+}

apache-rocketmq/src/main/java/com/baeldung/rocketmq/producer/CartEventProducer.java

@@ -0,0 +1,26 @@
+package com.baeldung.rocketmq.producer;
+
+
+import com.baeldung.rocketmq.event.CartItemEvent;
+import org.apache.rocketmq.spring.core.RocketMQTemplate;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class CartEventProducer implements CommandLineRunner {
+
+    @Autowired
+    private RocketMQTemplate rocketMQTemplate;
+
+    public static void main(String[] args) {
+        SpringApplication.run(CartEventProducer.class, args);
+    }
+
+    public void run(String... args) throws Exception {
+        rocketMQTemplate.convertAndSend("cart-item-add-topic", new CartItemEvent("bike", 1));
+        rocketMQTemplate.convertAndSend("cart-item-add-topic", new CartItemEvent("computer", 2));
+        rocketMQTemplate.convertAndSend("cart-item-removed-topic", new CartItemEvent("bike", 1));
+    }
+}

apache-rocketmq/src/main/java/com/baeldung/rocketmq/transaction/TransactionListenerImpl.java

@@ -0,0 +1,21 @@
+package com.baeldung.rocketmq.transaction;
+
+import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
+import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
+import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
+import org.springframework.messaging.Message;
+
+@RocketMQTransactionListener(txProducerGroup = "test-transaction")
+class TransactionListenerImpl implements RocketMQLocalTransactionListener {
+    @Override
+    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
+        // ... local transaction process, return ROLLBACK, COMMIT or UNKNOWN
+        return RocketMQLocalTransactionState.UNKNOWN;
+    }
+
+    @Override
+    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
+        // ... check transaction status and return ROLLBACK, COMMIT or UNKNOWN
+        return RocketMQLocalTransactionState.COMMIT;
+    }
+}

apache-rocketmq/src/main/resources/application.properties

@@ -0,0 +1,9 @@
+rocketmq.name-server=127.0.0.1:9876
+rocketmq.producer.group=my-group
+rocketmq.producer.send-message-timeout=300000
+rocketmq.producer.compress-message-body-threshold=4096
+rocketmq.producer.max-message-size=4194304
+rocketmq.producer.retry-times-when-send-async-failed=0
+rocketmq.producer.retry-next-server=true
+rocketmq.producer.retry-times-when-send-failed=2
+

aws/README.md

@@ -1,6 +1,6 @@
 ## AWS
 
-This module contains articles about AWS
+This module contains articles about Amazon Web Services (AWS)
 
 ### Relevant articles
 

core-groovy-2/src/main/groovy/com/baeldung/metaprogramming/extension/BasicExtensions.groovy

@@ -2,10 +2,13 @@ package com.baeldung.metaprogramming.extension
 
 import com.baeldung.metaprogramming.Employee
 
+import java.time.LocalDate
+import java.time.Year
+
 class BasicExtensions {
     
     static int getYearOfBirth(Employee self) {
-        return (new Date().getYear() + 1900) - self.age;
+        return Year.now().value - self.age
     }
     
     static String capitalize(String self) {

core-groovy-2/src/test/groovy/com/baeldung/metaprogramming/MetaprogrammingUnitTest.groovy

@@ -1,6 +1,9 @@
 package com.baeldung.metaprogramming
 
-import groovy.time.TimeCategory
+
+import java.time.LocalDate
+import java.time.Period
+import java.time.Year
 
 class MetaprogrammingUnitTest extends GroovyTestCase {
 
@@ -51,14 +54,16 @@ class MetaprogrammingUnitTest extends GroovyTestCase {
 
     void testJavaMetaClass() {
         String.metaClass.capitalize = { String str ->
-            str.substring(0, 1).toUpperCase() + str.substring(1);
+            str.substring(0, 1).toUpperCase() + str.substring(1)
         }
         assert "norman".capitalize() == "Norman"
     }
 
     void testEmployeeExtension() {
-        Employee emp = new Employee(age: 28)
+        def age = 28
-        assert emp.getYearOfBirth() == 1991
+        def expectedYearOfBirth = Year.now() - age
+        Employee emp = new Employee(age: age)
+        assert emp.getYearOfBirth() == expectedYearOfBirth.value
     }
 
     void testJavaClassesExtensions() {

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

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

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

@@ -0,0 +1,52 @@
+<?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>
+	<groupId>com.baeldung</groupId>
+	<artifactId>core-java-14</artifactId>
+	<version>1.0.0-SNAPSHOT</version>
+	<name>core-java-14</name>
+	<packaging>jar</packaging>
+	<url>http://maven.apache.org</url>
+
+	<parent>
+		<groupId>com.baeldung</groupId>
+		<artifactId>parent-modules</artifactId>
+		<version>1.0.0-SNAPSHOT</version>
+		<relativePath>../../</relativePath>
+	</parent>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>${maven-compiler-plugin.version}</version>
+				<configuration>
+					<source>${maven.compiler.source.version}</source>
+					<target>${maven.compiler.target.version}</target>
+					<compilerArgs>
+						<compilerArg>
+							--enable-preview
+						</compilerArg>
+					</compilerArgs>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>3.0.0-M3</version>
+				<configuration>
+					<argLine>--enable-preview</argLine>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
+	<properties>
+		<maven.compiler.source.version>14</maven.compiler.source.version>
+		<maven.compiler.target.version>14</maven.compiler.target.version>
+	</properties>
+
+</project>

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

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

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

@@ -19,6 +19,16 @@
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
             <version>${commons-lang3.version}</version>
+        </dependency>
+		<dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh.version}</version>
         </dependency>
         <!-- test scoped -->
         <dependency>
@@ -37,9 +47,34 @@
                 <filtering>true</filtering>
             </resource>
         </resources>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-shade-plugin</artifactId>
+				<version>3.2.0</version>
+				<executions>
+					<execution>
+						<phase>package</phase>
+						<goals>
+							<goal>shade</goal>
+						</goals>
+						<configuration>
+							<finalName>benchmarks</finalName>
+							<transformers>
+								<transformer
+										implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+									<mainClass>org.openjdk.jmh.Main</mainClass>
+								</transformer>
+							</transformers>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
     </build>
 
     <properties>
+		<jmh.version>1.19</jmh.version>
         <!-- util -->
         <commons-lang3.version>3.9</commons-lang3.version>
         <!-- testing -->

core-java-modules/core-java-arrays-2/src/main/java/com/baeldung/arraysort/ArraySortingBenchmark.java

@@ -0,0 +1,72 @@
+package com.baeldung.arraysort;
+
+import java.util.Arrays;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5)
+@Measurement(iterations = 10)
+@Fork(2)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+public class ArraySortingBenchmark {
+
+    @State(Scope.Benchmark)
+    public static class ArrayContainer {
+
+        @Param({ "1000", "10000", "100000", "1000000" })
+        int arraySize;
+
+        // initial unsorted array
+        int[] unsortedArray;
+        
+        //cloned array to sort
+        int[] arrayToSort;
+
+        @Setup(Level.Trial)
+        public void createUnSortedArray() {
+            unsortedArray = new int[arraySize];
+            for (int i = 0; i < arraySize; i++) {
+                unsortedArray[i] = new Random().nextInt(1000);
+            }
+        }
+
+        @Setup(Level.Invocation)
+        public void createUnSortedArrayCopy() {
+            arrayToSort = unsortedArray.clone();
+        }
+
+        int[] getArrayToSort() {
+            return arrayToSort;
+        }
+    }
+
+    @Benchmark
+    public void benchmark_arrays_parallel_sort(ArrayContainer d, Blackhole b) {
+        int[] arr = d.getArrayToSort();
+        Arrays.parallelSort(arr);
+        b.consume(arr);
+    }
+
+    @Benchmark
+    public void benchmark_arrays_sort(ArrayContainer d, Blackhole b) {
+        int[] arr = d.getArrayToSort();
+        Arrays.sort(arr);
+        b.consume(arr);
+    }
+
+}

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-collections-list-3/src/main/java/com/baeldung/list/duplicatescounter/DuplicatesCounter.java

@@ -24,11 +24,21 @@ public class DuplicatesCounter {
         return resultMap;
     }
 
-    public static <T> Map<T, Long> countByClassicalLoopWithMapCompute(List<T> inputList) {
+    public static <T> Map<T, Long> countByForEachLoopWithGetOrDefault(List<T> inputList) {
         Map<T, Long> resultMap = new HashMap<>();
-        for (T element : inputList) {
+        inputList.forEach(e -> resultMap.put(e, resultMap.getOrDefault(e, 0L) + 1L));
-            resultMap.compute(element, (k, v) -> v == null ? 1 : v + 1);
+        return resultMap;
     }
+
+    public static <T> Map<T, Long> countByForEachLoopWithMapCompute(List<T> inputList) {
+        Map<T, Long> resultMap = new HashMap<>();
+        inputList.forEach(e -> resultMap.compute(e, (k, v) -> v == null ? 1L : v + 1L));
+        return resultMap;
+    }
+
+    public static <T> Map<T, Long> countByForEachLoopWithMapMerge(List<T> inputList) {
+        Map<T, Long> resultMap = new HashMap<>();
+        inputList.forEach(e -> resultMap.merge(e, 1L, Long::sum));
         return resultMap;
     }
 

core-java-modules/core-java-collections-list-3/src/test/java/com/baeldung/list/duplicatescounter/DuplicatesCounterUnitTest.java

@@ -11,7 +11,6 @@ import static org.assertj.core.data.MapEntry.entry;
 
 class DuplicatesCounterUnitTest {
 
-
     private static List<String> INPUT_LIST = Lists.list(
         "expect1",
         "expect2", "expect2",
@@ -24,10 +23,21 @@ class DuplicatesCounterUnitTest {
         verifyResult(result);
     }
 
+    @Test
+    void givenInput_whenCountByForEachLoopWithGetOrDefault_thenGetResultMap() {
+        Map<String, Long> result = DuplicatesCounter.countByForEachLoopWithGetOrDefault(INPUT_LIST);
+        verifyResult(result);
+    }
 
     @Test
-    void givenInput_whenCountByClassicalLoopWithMapCompute_thenGetResultMap() {
+    void givenInput_whenCountByForEachLoopWithMapCompute_thenGetResultMap() {
-        Map<String, Long> result = DuplicatesCounter.countByClassicalLoopWithMapCompute(INPUT_LIST);
+        Map<String, Long> result = DuplicatesCounter.countByForEachLoopWithMapCompute(INPUT_LIST);
+        verifyResult(result);
+    }
+
+    @Test
+    void givenInput_whenCountByForEachLoopWithMapMerge_thenGetResultMap() {
+        Map<String, Long> result = DuplicatesCounter.countByForEachLoopWithMapMerge(INPUT_LIST);
         verifyResult(result);
     }
 

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

@@ -1,5 +1,3 @@
-=========
-
 ## Core Java Concurrency Advanced Examples
 
 This module contains articles about advanced topics about multithreading with core Java.

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

@@ -23,6 +23,37 @@
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
+        
+        <dependency>
+            <groupId>com.jcabi</groupId>
+            <artifactId>jcabi-aspects</artifactId>
+            <version>${jcabi-aspects.version}</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjrt</artifactId>
+            <version>${aspectjrt.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.cactoos</groupId>
+            <artifactId>cactoos</artifactId>
+            <version>${cactoos.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.ea.async</groupId>
+            <artifactId>ea-async</artifactId>
+            <version>${ea-async.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -36,6 +67,30 @@
                     <target>${maven.compiler.target}</target>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>com.jcabi</groupId>
+                <artifactId>jcabi-maven-plugin</artifactId>
+                <version>${jcabi-maven-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>ajc</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.aspectj</groupId>
+                        <artifactId>aspectjtools</artifactId>
+                        <version>${aspectjtools.version}</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.aspectj</groupId>
+                        <artifactId>aspectjweaver</artifactId>
+                        <version>${aspectjweaver.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
         </plugins>
         <resources>
             <resource>
@@ -49,6 +104,14 @@
         <assertj.version>3.14.0</assertj.version>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
+        <jcabi-aspects.version>0.22.6</jcabi-aspects.version>
+        <aspectjrt.version>1.9.5</aspectjrt.version>
+        <guava.version>28.2-jre</guava.version>
+        <cactoos.version>0.43</cactoos.version>
+        <ea-async.version>1.2.3</ea-async.version>
+        <jcabi-maven-plugin.version>0.14.1</jcabi-maven-plugin.version>
+        <aspectjtools.version>1.9.1</aspectjtools.version>
+        <aspectjweaver.version>1.9.1</aspectjweaver.version>
     </properties>
 
 </project>

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/async/EAAsyncExample.java

@@ -0,0 +1,57 @@
+package com.baeldung.async;
+
+import static com.ea.async.Async.await;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+import com.ea.async.Async;
+
+public class EAAsyncExample {
+
+    static {
+        Async.init();
+    }
+
+    public static void main(String[] args) throws Exception {
+        usingCompletableFuture();
+        usingAsyncAwait();
+    }
+
+    public static void usingCompletableFuture() throws InterruptedException, ExecutionException, Exception {
+        CompletableFuture<Void> completableFuture = hello()
+            .thenComposeAsync(hello -> mergeWorld(hello))
+            .thenAcceptAsync(helloWorld -> print(helloWorld))
+            .exceptionally( throwable -> {
+                System.out.println(throwable.getCause()); 
+                return null;
+            });
+        completableFuture.get();
+    }
+
+    public static CompletableFuture<String> hello() {
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Hello");
+        return completableFuture;
+    }
+
+    public static CompletableFuture<String> mergeWorld(String s) {
+        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
+            return s + " World!";
+        });
+        return completableFuture;
+    }
+
+    public static void print(String str) {
+        CompletableFuture.runAsync(() -> System.out.println(str));
+    }
+
+    private static void usingAsyncAwait() {
+        try {
+            String hello = await(hello());
+            String helloWorld = await(mergeWorld(hello));
+            await(CompletableFuture.runAsync(() -> print(helloWorld)));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/async/JavaAsync.java

@@ -0,0 +1,183 @@
+package com.baeldung.async;
+
+import static com.ea.async.Async.await;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import com.google.common.util.concurrent.AsyncCallable;
+import com.google.common.util.concurrent.Callables;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.jcabi.aspects.Async;
+import com.jcabi.aspects.Loggable;
+
+public class JavaAsync {
+
+    static {
+        com.ea.async.Async.init();
+    }
+
+    private static final ExecutorService threadpool = Executors.newCachedThreadPool();
+
+    public static void main (String[] args) throws InterruptedException, ExecutionException {
+        int number = 20;
+
+        //Thread Example
+        factorialUsingThread(number).start();
+
+        //FutureTask Example
+        Future<Long> futureTask = factorialUsingFutureTask(number);
+        System.out.println("Factorial of " + number + " is: " + futureTask.get());
+
+        // CompletableFuture Example
+        Future<Long> completableFuture = factorialUsingCompletableFuture(number);
+        System.out.println("Factorial of " + number + " is: " + completableFuture.get());
+
+        // EA Async example
+        System.out.println("Factorial of " + number + " is: " + factorialUsingEAAsync(number));
+
+        // cactoos async example
+        Future<Long> asyncFuture = factorialUsingCactoos(number);
+        System.out.println("Factorial of " + number + " is: " + asyncFuture.get());
+
+        // Guava example
+        ListenableFuture<Long> guavaFuture = factorialUsingGuavaServiceSubmit(number);
+        System.out.println("Factorial of " + number + " is: " + guavaFuture.get());
+
+        ListenableFuture<Long> guavaFutures = factorialUsingGuavaFutures(number);
+        System.out.println("Factorial of " + number + " is: " + guavaFutures.get());
+
+        // @async jcabi-aspect example
+        Future<Long> aspectFuture = factorialUsingJcabiAspect(number);
+        System.out.println("Factorial of " + number + " is: " + aspectFuture.get());
+
+    }
+
+    /**
+     * Finds factorial of a number
+     * @param number
+     * @return
+     */
+    public static long factorial(int number) {
+        long result = 1; 
+        for(int i=number;i>0;i--) {
+            result *= i; 
+        } 
+        return result; 
+    }
+
+    /**
+     * Finds factorial of a number using Thread
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static Thread factorialUsingThread(int number) {
+        Thread newThread = new Thread(() -> {
+            System.out.println("Factorial of " + number + " is: " + factorial(number));
+        });
+
+        return newThread;
+    }
+
+    /**
+     * Finds factorial of a number using FutureTask
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static Future<Long> factorialUsingFutureTask(int number) {
+        Future<Long> futureTask = threadpool.submit(() -> factorial(number)); 
+
+        while (!futureTask.isDone()) { 
+            System.out.println("FutureTask is not finished yet..."); 
+        } 
+
+        return futureTask;
+    }
+
+    /**
+     * Finds factorial of a number using CompletableFuture
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static Future<Long> factorialUsingCompletableFuture(int number) {
+        CompletableFuture<Long> completableFuture = CompletableFuture.supplyAsync(() -> factorial(number));
+        return completableFuture;
+    }
+
+    /**
+     * Finds factorial of a number using EA Async
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static long factorialUsingEAAsync(int number) {
+        CompletableFuture<Long> completableFuture = CompletableFuture.supplyAsync(() -> factorial(number));
+        long result = await(completableFuture);
+        return result;
+    }
+
+    /**
+     * Finds factorial of a number using Async of Cactoos
+     * @param number
+     * @return
+     * @throws InterruptedException
+     * @throws ExecutionException
+     */
+    @Loggable
+    public static Future<Long> factorialUsingCactoos(int number) throws InterruptedException, ExecutionException {
+        org.cactoos.func.Async<Integer, Long> asyncFunction = new org.cactoos.func.Async<Integer, Long>(input -> factorial(input));
+        Future<Long> asyncFuture = asyncFunction.apply(number);
+        return asyncFuture;
+    }
+
+    /**
+     * Finds factorial of a number using Guava's ListeningExecutorService.submit()
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static ListenableFuture<Long> factorialUsingGuavaServiceSubmit(int number) {
+        ListeningExecutorService service = MoreExecutors.listeningDecorator(threadpool);
+        ListenableFuture<Long> factorialFuture = (ListenableFuture<Long>) service.submit(()-> factorial(number));
+        return factorialFuture;
+    }
+
+    /**
+     * Finds factorial of a number using Guava's Futures.submitAsync()
+     * @param number
+     * @return
+     */
+    @Loggable
+    public static ListenableFuture<Long> factorialUsingGuavaFutures(int number) {
+        ListeningExecutorService service = MoreExecutors.listeningDecorator(threadpool);
+        AsyncCallable<Long> asyncCallable = Callables.asAsyncCallable(new Callable<Long>() {
+            public Long call() {
+                return factorial(number);
+            }
+        }, service);
+        return Futures.submitAsync(asyncCallable, service);
+    }
+
+    /**
+     * Finds factorial of a number using @Async of jcabi-aspects
+     * @param number
+     * @return
+     */
+    @Async
+    @Loggable
+    public static Future<Long> factorialUsingJcabiAspect(int number) {
+        Future<Long> factorialFuture = CompletableFuture.supplyAsync(() -> factorial(number));
+        return factorialFuture;
+    }
+
+}

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

@@ -1,6 +1,6 @@
-=========
+## Core Java Concurrency Basic
 
-## Core Java Concurrency Basic 2 Examples
+This module contains articles about basic Java concurrency
 
 ### Relevant Articles: 
 - [How to Delay Code Execution in Java](https://www.baeldung.com/java-delay-code-execution)
@@ -8,3 +8,4 @@
 - [Difference Between Wait and Sleep in Java](https://www.baeldung.com/java-wait-and-sleep)
 - [Guide to the Synchronized Keyword in Java](https://www.baeldung.com/java-synchronized)
 - [Life Cycle of a Thread in Java](https://www.baeldung.com/java-thread-lifecycle)
+- [[<-- Prev]](/core-java-modules/core-java-concurrency-basic)

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

@@ -1,6 +1,5 @@
-## Java Date/time computations Cookbooks and Examples
+## Core Date Operations (Part 1)
-
+This module contains articles about date operations in Java.
-This module contains articles about date and time computations in Java.
 
 ### Relevant Articles: 
 - [Difference Between Two Dates in Java](http://www.baeldung.com/java-date-difference)
@@ -13,3 +12,4 @@ This module contains articles about date and time computations in Java.
 - [Increment Date in Java](http://www.baeldung.com/java-increment-date)
 - [Add Hours To a Date In Java](http://www.baeldung.com/java-add-hours-date)
 - [Introduction to Joda-Time](http://www.baeldung.com/joda-time)
+- [[Next -->]](/core-java-modules/core-java-date-operations-2)

core-java-modules/core-java-date-operations-1/pom.xml

@@ -2,9 +2,9 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <artifactId>core-java-datetime-computations</artifactId>
+    <artifactId>core-java-date-operations-1</artifactId>
     <version>${project.parent.version}</version>
-    <name>core-java-datetime-computations</name>
+    <name>core-java-date-operations-1</name>
     <packaging>jar</packaging>
 
     <parent>
@@ -41,7 +41,7 @@
     </dependencies>
 
     <build>
-        <finalName>core-java-datetime-computations</finalName>
+        <finalName>core-java-date-operations-1</finalName>
         <resources>
             <resource>
                 <directory>src/main/resources</directory>