Merge branch 'master' into master

algorithms/src/main/java/com/baeldung/algorithms/binarysearch/BinarySearch.java

@@ -1,3 +1,5 @@
+package com.baeldung.algorithms.binarysearch;
+
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForce.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionBruteForce {
+
+    public static <T> boolean detectCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> it1 = head;
+        int nodesTraversedByOuter = 0;
+        while (it1 != null && it1.next != null) {
+            it1 = it1.next;
+            nodesTraversedByOuter++;
+
+            int x = nodesTraversedByOuter;
+            Node<T> it2 = head;
+            int noOfTimesCurrentNodeVisited = 0;
+
+            while (x > 0) {
+                it2 = it2.next;
+
+                if (it2 == it1) {
+                    noOfTimesCurrentNodeVisited++;
+                }
+
+                if (noOfTimesCurrentNodeVisited == 2) {
+                    return true;
+                }
+
+                x--;
+            }
+        }
+
+        return false;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIterators.java

@@ -0,0 +1,25 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionByFastAndSlowIterators {
+
+    public static <T> boolean detectCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashing.java

@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.linkedlist;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class CycleDetectionByHashing {
+
+    public static <T> boolean detectCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Set<Node<T>> set = new HashSet<>();
+        Node<T> node = head;
+
+        while (node != null) {
+            if (set.contains(node)) {
+                return true;
+            }
+            set.add(node);
+            node = node.next;
+        }
+
+        return false;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForce.java

@@ -0,0 +1,61 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalBruteForce {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                removeCycle(slow, head);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
+        Node<T> it = head;
+
+        while (it != null) {
+            if (isNodeReachableFromLoopNode(it, loopNodeParam)) {
+                Node<T> loopStart = it;
+                findEndNodeAndBreakCycle(loopStart);
+                break;
+            }
+            it = it.next;
+        }
+    }
+
+    private static <T> boolean isNodeReachableFromLoopNode(Node<T> it, Node<T> loopNodeParam) {
+        Node<T> loopNode = loopNodeParam;
+
+        while (loopNode.next != loopNodeParam) {
+            if (it == loopNode) {
+                return true;
+            }
+            loopNode = loopNode.next;
+        }
+
+        return false;
+    }
+
+    private static <T> void findEndNodeAndBreakCycle(Node<T> loopStartParam) {
+        Node<T> loopStart = loopStartParam;
+
+        while (loopStart.next != loopStartParam) {
+            loopStart = loopStart.next;
+        }
+
+        loopStart.next = null;
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodes.java

@@ -0,0 +1,55 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalByCountingLoopNodes {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                int cycleLength = calculateCycleLength(slow);
+                removeCycle(head, cycleLength);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static <T> void removeCycle(Node<T> head, int cycleLength) {
+        Node<T> cycleLengthAdvancedIterator = head;
+        Node<T> it = head;
+
+        for (int i = 0; i < cycleLength; i++) {
+            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
+        }
+
+        while (it.next != cycleLengthAdvancedIterator.next) {
+            it = it.next;
+            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
+        }
+
+        cycleLengthAdvancedIterator.next = null;
+    }
+
+    private static <T> int calculateCycleLength(Node<T> loopNodeParam) {
+        Node<T> loopNode = loopNodeParam;
+        int length = 1;
+
+        while (loopNode.next != loopNodeParam) {
+            length++;
+            loopNode = loopNode.next;
+        }
+
+        return length;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodes.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalWithoutCountingLoopNodes {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                removeCycle(slow, head);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static <T> void removeCycle(Node<T> meetingPointParam, Node<T> head) {
+        Node<T> loopNode = meetingPointParam;
+        Node<T> it = head;
+
+        while (loopNode.next != it.next) {
+            it = it.next;
+            loopNode = loopNode.next;
+        }
+
+        loopNode.next = null;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/Node.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class Node<T> {
+    T data;
+    Node<T> next;
+
+    public static <T> Node<T> createNewNode(T data, Node<T> next) {
+        Node<T> node = new Node<T>();
+        node.data = data;
+        node.next = next;
+        return node;
+    }
+
+    public static <T> void traverseList(Node<T> root) {
+        if (root == null) {
+            return;
+        }
+
+        Node<T> node = root;
+        while (node != null) {
+            System.out.println(node.data);
+            node = node.next;
+        }
+    }
+
+    public static <T> Node<T> getTail(Node<T> root) {
+        if (root == null) {
+            return null;
+        }
+
+        Node<T> node = root;
+        while (node.next != null) {
+            node = node.next;
+        }
+        return node;
+    }
+
+}

algorithms/src/test/java/algorithms/binarysearch/BinarySearchTest.java

@@ -1,9 +1,11 @@
+package algorithms.binarysearch;
+
 import java.util.Arrays;
 import java.util.List;
 
 import org.junit.Assert;
 import org.junit.Test;
-
+import com.baeldung.algorithms.binarysearch.BinarySearch;
 
 public class BinarySearchTest {
 

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForceTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleDetectionBruteForceTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleDetectionBruteForce.detectCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleDetectionBruteForce.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIteratorsTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleDetectionByFastAndSlowIteratorsTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashingTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleDetectionByHashingTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleDetectionByHashing.detectCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleDetectionByHashing.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionTestBase.java

@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionTestBase {
+
+    public static Node<Integer> createList() {
+        Node<Integer> root = Node.createNewNode(10, null);
+
+        for (int i = 9; i >= 1; --i) {
+            Node<Integer> current = Node.createNewNode(i, root);
+            root = current;
+        }
+
+        return root;
+    }
+
+    public static void createLoop(Node<Integer> root) {
+        Node<Integer> tail = Node.getTail(root);
+
+        Node<Integer> middle = root;
+        for (int i = 1; i <= 4; i++) {
+            middle = middle.next;
+        }
+
+        tail.next = middle;
+    }
+
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForceTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleRemovalBruteForceTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleRemovalBruteForce.detectAndRemoveCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectAndRemoveLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleRemovalBruteForce.detectAndRemoveCycle(root));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodesTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleRemovalByCountingLoopNodesTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectAndRemoveLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(root));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodesTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleRemovalWithoutCountingLoopNodesTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectAndRemoveLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(root));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+}

core-java/src/main/java/com/baeldung/numberofdigits/Benchmarking.java

@@ -1,131 +1,67 @@
 package com.baeldung.numberofdigits;
 
-import static com.baeldung.designpatterns.util.LogerUtil.LOG;;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
 
-public class Benchmarking {;
-
-    private static final int LOWER_BOUND = 1;
-    private static final int UPPER_BOUND = 999999999;
-
-    
-    public static void main(String[] args) {
-        LOG.info("Testing all methods...");
-        
-        long length = test_stringBasedSolution();
-        LOG.info("String Based Solution : " + length);
-        
-        length = test_logarithmicApproach();
-        LOG.info("Logarithmic Approach : " + length);
-        
-        length = test_repeatedMultiplication();
-        LOG.info("Repeated Multiplication : " + length);
-        
-        length = test_shiftOperators();
-        LOG.info("Shift Operators : " + length);
-        
-        length = test_dividingWithPowersOf2();
-        LOG.info("Dividing with Powers of 2 : " + length);
-        
-        length = test_divideAndConquer();
-        LOG.info("Divide And Conquer : " + length);
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.runner.RunnerException;
 
+public class Benchmarking {
+    public static void main(String[] args) throws RunnerException, IOException {
+        org.openjdk.jmh.Main.main(args);
     }
 
-    private static long test_stringBasedSolution() {
-        
-        long startTime, stopTime, elapsedTime;
-        startTime = System.currentTimeMillis();
-
-        int total = 0;
-        for (int i = LOWER_BOUND; i <= UPPER_BOUND; i++) {
-            total += NumberOfDigits.stringBasedSolution(i);
-        }
-
-        stopTime = System.currentTimeMillis();
-        elapsedTime = stopTime - startTime;
-        
-        return elapsedTime;
-    }
-
-    private static long test_logarithmicApproach() {
-        
-        long startTime, stopTime, elapsedTime;
-        startTime = System.currentTimeMillis();
-
-        int total = 0;
-        for (int i = LOWER_BOUND; i <= UPPER_BOUND; i++) {
-            total += NumberOfDigits.logarithmicApproach(i);
-        }
-
-        stopTime = System.currentTimeMillis();
-        elapsedTime = stopTime - startTime;
-        
-        return elapsedTime;
-    }
-
-    private static long test_repeatedMultiplication() {
-        
-        long startTime, stopTime, elapsedTime;
-        startTime = System.currentTimeMillis();
-
-        int total = 0;
-        for (int i = LOWER_BOUND; i <= UPPER_BOUND; i++) {
-            total += NumberOfDigits.repeatedMultiplication(i);
-        }
-
-        stopTime = System.currentTimeMillis();
-        elapsedTime = stopTime - startTime;
-        
-        return elapsedTime;
-    }
-
-    private static long test_shiftOperators() {
-        
-        long startTime, stopTime, elapsedTime;
-        startTime = System.currentTimeMillis();
-
-        int total = 0;
-        for (int i = LOWER_BOUND; i <= UPPER_BOUND; i++) {
-            total += NumberOfDigits.shiftOperators(i);
-        }
-
-        stopTime = System.currentTimeMillis();
-        elapsedTime = stopTime - startTime;
-        
-        return elapsedTime;
-    }
-
-    private static long test_dividingWithPowersOf2() {
-        
-        long startTime, stopTime, elapsedTime;
-        startTime = System.currentTimeMillis();
-
-        int total = 0;
-        for (int i = LOWER_BOUND; i <= UPPER_BOUND; i++) {
-            total += NumberOfDigits.dividingWithPowersOf2(i);
-        }
-
-        stopTime = System.currentTimeMillis();
-        elapsedTime = stopTime - startTime;
-        
-        return elapsedTime;
-    }
-
-    private static long test_divideAndConquer() {
-        
-        long startTime, stopTime, elapsedTime;
-        startTime = System.currentTimeMillis();
-
-        int total = 0;
-        for (int i = LOWER_BOUND; i <= UPPER_BOUND; i++) {
-            total += NumberOfDigits.divideAndConquer(i);
-        }
-
-        stopTime = System.currentTimeMillis();
-        elapsedTime = stopTime - startTime;
-        
-        return elapsedTime;
+    @State(Scope.Thread)
+    public static class ExecutionPlan {
+        public int number = Integer.MAX_VALUE;
+        public int length = 0;
+        public NumberOfDigits numberOfDigits= new NumberOfDigits();
     }
     
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void stringBasedSolution(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.stringBasedSolution(plan.number);
+    }
     
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void logarithmicApproach(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.logarithmicApproach(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void repeatedMultiplication(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.repeatedMultiplication(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void shiftOperators(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.shiftOperators(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void dividingWithPowersOf2(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.dividingWithPowersOf2(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void divideAndConquer(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.divideAndConquer(plan.number);
+    }
 }

core-java/src/main/java/com/baeldung/numberofdigits/NumberOfDigits.java

@@ -1,17 +1,17 @@
 package com.baeldung.numberofdigits;
 
 public class NumberOfDigits {
-    public static int stringBasedSolution(int number) {
+    public int stringBasedSolution(int number) {
         int length = String.valueOf(number).length();
         return length;
     }
     
-    public static int logarithmicApproach(int number) {
+    public int logarithmicApproach(int number) {
         int length = (int) Math.log10(number) + 1;
         return length;
     }
     
-    public static int repeatedMultiplication(int number) {
+    public int repeatedMultiplication(int number) {
         int length = 0;
         long temp = 1;
         while(temp <= number) {
@@ -21,7 +21,7 @@ public class NumberOfDigits {
         return length;
     }
 
-    public static int shiftOperators(int number) {
+    public int shiftOperators(int number) {
         int length = 0;
         long temp = 1;
         while(temp <= number) {
@@ -31,7 +31,7 @@ public class NumberOfDigits {
         return length;
     }
     
-    public static int dividingWithPowersOf2(int number) {
+    public int dividingWithPowersOf2(int number) {
         int length = 1;
         if (number >= 100000000) {
             length += 8;
@@ -51,7 +51,7 @@ public class NumberOfDigits {
         return length;
     }
     
-    public static int divideAndConquer(int number) {
+    public int divideAndConquer(int number) {
         if (number < 100000){
             // 5 digits or less
             if (number < 100){

core-java/src/main/java/com/baeldung/numberofdigits/NumberOfDigitsDriver.java

@@ -1,27 +1,33 @@
-package com.baeldung.numberofdigits;
-
-import static com.baeldung.designpatterns.util.LogerUtil.LOG;
-
-public class NumberOfDigitsDriver {
-    public static void main(String[] args) {
-        LOG.info("Testing all methods...");
-        
-        long length = NumberOfDigits.stringBasedSolution(602);
-        LOG.info("String Based Solution : " + length);
-        
-        length = NumberOfDigits.logarithmicApproach(602);
-        LOG.info("Logarithmic Approach : " + length);
-        
-        length = NumberOfDigits.repeatedMultiplication(602);
-        LOG.info("Repeated Multiplication : " + length);
-        
-        length = NumberOfDigits.shiftOperators(602);
-        LOG.info("Shift Operators : " + length);
-        
-        length = NumberOfDigits.dividingWithPowersOf2(602);
-        LOG.info("Dividing with Powers of 2 : " + length);
-        
-        length = NumberOfDigits.divideAndConquer(602);
-        LOG.info("Divide And Conquer : " + length);
-    }
-}
+package com.baeldung.numberofdigits;
+
+import static com.baeldung.designpatterns.util.LogerUtil.LOG;
+
+public class NumberOfDigitsDriver {
+    private static NumberOfDigits numberOfDigits;
+    
+    static {
+        numberOfDigits = new NumberOfDigits();
+    }
+    
+    public static void main(String[] args) {
+        LOG.info("Testing all methods...");
+        
+        long length = numberOfDigits.stringBasedSolution(602);
+        LOG.info("String Based Solution : " + length);
+        
+        length = numberOfDigits.logarithmicApproach(602);
+        LOG.info("Logarithmic Approach : " + length);
+        
+        length = numberOfDigits.repeatedMultiplication(602);
+        LOG.info("Repeated Multiplication : " + length);
+        
+        length = numberOfDigits.shiftOperators(602);
+        LOG.info("Shift Operators : " + length);
+        
+        length = numberOfDigits.dividingWithPowersOf2(602);
+        LOG.info("Dividing with Powers of 2 : " + length);
+        
+        length = numberOfDigits.divideAndConquer(602);
+        LOG.info("Divide And Conquer : " + length);
+    }
+}

core-java/src/main/java/com/baeldung/sneakythrows/SneakyRunnable.java

@@ -0,0 +1,23 @@
+package com.baeldung.sneakythrows;
+
+import lombok.SneakyThrows;
+
+public class SneakyRunnable implements Runnable {
+
+    @SneakyThrows
+    public void run() {
+        try {
+            throw new InterruptedException();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+        try {
+            new SneakyRunnable().run();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java/src/main/java/com/baeldung/sneakythrows/SneakyThrows.java

@@ -0,0 +1,25 @@
+package com.baeldung.sneakythrows;
+
+import java.io.IOException;
+
+public class SneakyThrows {
+
+
+    public static <E extends Throwable> void sneakyThrow(Throwable e) throws E {
+        throw (E) e;
+    }
+
+    public static void throwsSneakyIOException() {
+        sneakyThrow(new IOException("sneaky"));
+    }
+
+
+    public static void main(String[] args) {
+        try {
+            throwsSneakyIOException();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+
+    }
+}

core-java/src/main/java/com/baeldung/stream/StreamIndices.java

@@ -7,31 +7,56 @@ import java.util.stream.IntStream;
 import com.codepoetics.protonpack.Indexed;
 import com.codepoetics.protonpack.StreamUtils;
 
+import io.vavr.collection.Stream;
+import one.util.streamex.EntryStream;
+
 public class StreamIndices {
 
     public static List<String> getEvenIndexedStrings(String[] names) {
         List<String> evenIndexedNames = IntStream.range(0, names.length)
-          .filter(i -> i % 2 == 0).mapToObj(i -> names[i])
-          .collect(Collectors.toList());
+            .filter(i -> i % 2 == 0)
+            .mapToObj(i -> names[i])
+            .collect(Collectors.toList());
+        return evenIndexedNames;
+    }
+
+    public List<String> getEvenIndexedStringsVersionTwo(List<String> names) {
+        List<String> evenIndexedNames = EntryStream.of(names)
+            .filterKeyValue((index, name) -> index % 2 == 0)
+            .values()
+            .toList();
         return evenIndexedNames;
     }
 
     public static List<Indexed<String>> getEvenIndexedStrings(List<String> names) {
         List<Indexed<String>> list = StreamUtils.zipWithIndex(names.stream())
-          .filter(i -> i.getIndex() % 2 == 0).collect(Collectors.toList());
+            .filter(i -> i.getIndex() % 2 == 0)
+            .collect(Collectors.toList());
         return list;
     }
 
     public static List<Indexed<String>> getOddIndexedStrings(List<String> names) {
         List<Indexed<String>> list = StreamUtils.zipWithIndex(names.stream())
-          .filter(i -> i.getIndex() % 2 == 1).collect(Collectors.toList());
+            .filter(i -> i.getIndex() % 2 == 1)
+            .collect(Collectors.toList());
         return list;
     }
 
     public static List<String> getOddIndexedStrings(String[] names) {
         List<String> oddIndexedNames = IntStream.range(0, names.length)
-          .filter(i -> i % 2 == 1).mapToObj(i -> names[i])
-          .collect(Collectors.toList());
+            .filter(i -> i % 2 == 1)
+            .mapToObj(i -> names[i])
+            .collect(Collectors.toList());
         return oddIndexedNames;
     }
+
+    public static List<String> getOddIndexedStringsVersionTwo(String[] names) {
+        List<String> oddIndexedNames = Stream.of(names)
+            .zipWithIndex()
+            .filter(tuple -> tuple._2 % 2 == 1)
+            .map(tuple -> tuple._1)
+            .toJavaList();
+        return oddIndexedNames;
+    }
+
 }

core-java/src/test/java/com/baeldung/numberofdigits/NumberOfDigitsIntegrationTest.java

@@ -9,7 +9,13 @@ import org.junit.runner.RunWith;
 
 @RunWith(Theories.class)
 public class NumberOfDigitsIntegrationTest {
-
+    
+    private static NumberOfDigits numberOfDigits;
+    
+    static {
+        numberOfDigits = new NumberOfDigits();
+    }
+    
     @DataPoints
     public static int[][] lowestIntegers()
     {
@@ -64,37 +70,37 @@ public class NumberOfDigitsIntegrationTest {
     @Theory
     public void givenDataPoints_whenStringBasedSolutionInvoked_thenAllPointsMatch(final int[] entry) {
         Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
-        Assert.assertEquals(entry[0], NumberOfDigits.stringBasedSolution(entry[1]));
+        Assert.assertEquals(entry[0], numberOfDigits.stringBasedSolution(entry[1]));
     }
 
     @Theory
     public void givenDataPoints_whenLogarithmicApproachInvoked_thenAllPointsMatch(final int[] entry) {
         Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
-        Assert.assertEquals(entry[0], NumberOfDigits.logarithmicApproach(entry[1]));
+        Assert.assertEquals(entry[0], numberOfDigits.logarithmicApproach(entry[1]));
     }
 
     @Theory
     public void givenDataPoints_whenRepeatedMultiplicationInvoked_thenAllPointsMatch(final int[] entry) {
         Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
-        Assert.assertEquals(entry[0], NumberOfDigits.repeatedMultiplication(entry[1]));
+        Assert.assertEquals(entry[0], numberOfDigits.repeatedMultiplication(entry[1]));
     }
 
     @Theory
     public void givenDataPoints_whenShiftOperatorsInvoked_thenAllPointsMatch(final int[] entry) {
         Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
-        Assert.assertEquals(entry[0], NumberOfDigits.shiftOperators(entry[1]));
+        Assert.assertEquals(entry[0], numberOfDigits.shiftOperators(entry[1]));
     }
 
     @Theory
     public void givenDataPoints_whenDividingWithPowersOf2Invoked_thenAllPointsMatch(final int[] entry) {
         Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
-        Assert.assertEquals(entry[0], NumberOfDigits.dividingWithPowersOf2(entry[1]));
+        Assert.assertEquals(entry[0], numberOfDigits.dividingWithPowersOf2(entry[1]));
     }
 
     @Theory
     public void givenDataPoints_whenDivideAndConquerInvoked_thenAllPointsMatch(final int[] entry) {
         Assume.assumeTrue(entry[0] > 0 && entry[1] > 0);
-        Assert.assertEquals(entry[0], NumberOfDigits.divideAndConquer(entry[1]));
+        Assert.assertEquals(entry[0], numberOfDigits.divideAndConquer(entry[1]));
     }
     
 }

core-java/src/test/java/com/baeldung/sneakythrows/SneakyRunnableTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.sneakythrows;
+
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class SneakyRunnableTest {
+
+    @Test
+    public void whenCallSneakyRunnableMethod_thenThrowException() {
+        try {
+            new SneakyRunnable().run();
+        } catch (Exception e) {
+            assertEquals(InterruptedException.class, e.getStackTrace());
+        }
+    }
+}

core-java/src/test/java/com/baeldung/sneakythrows/SneakyThrowsTest.java

@@ -0,0 +1,18 @@
+package com.baeldung.sneakythrows;
+
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class SneakyThrowsTest {
+
+    @Test
+    public void whenCallSneakyMethod_thenThrowSneakyException() {
+        try {
+            SneakyThrows.throwsSneakyIOException();
+        } catch (Exception ex) {
+            assertEquals("sneaky", ex.getMessage().toString());
+        }
+    }
+
+}

core-java/src/test/java/com/baeldung/stream/StreamIndicesTest.java

@@ -20,6 +20,15 @@ public class StreamIndicesTest {
         assertEquals(expectedResult, actualResult);
     }
 
+    @Test
+    public void givenArray_whenGetIndexedStrings_thenReturnListOfEvenIndexedStringsVersionTwo() {
+        String[] names = { "Afrim", "Bashkim", "Besim", "Lulzim", "Durim", "Shpetim" };
+        List<String> expectedResult = Arrays.asList("Afrim", "Besim", "Durim");
+        List<String> actualResult = StreamIndices.getEvenIndexedStrings(names);
+
+        assertEquals(expectedResult, actualResult);
+    }
+
     @Test
     public void givenArray_whenGetIndexedStrings_thenReturnListOfOddStrings() {
         String[] names = { "Afrim", "Bashkim", "Besim", "Lulzim", "Durim", "Shpetim" };
@@ -47,4 +56,13 @@ public class StreamIndicesTest {
         assertEquals(expectedResult, actualResult);
     }
 
+    @Test
+    public void givenArray_whenGetIndexedStrings_thenReturnListOfOddStringsVersionTwo() {
+        String[] names = { "Afrim", "Bashkim", "Besim", "Lulzim", "Durim", "Shpetim" };
+        List<String> expectedResult = Arrays.asList("Bashkim", "Lulzim", "Shpetim");
+        List<String> actualResult = StreamIndices.getOddIndexedStringsVersionTwo(names);
+
+        assertEquals(expectedResult, actualResult);
+    }
+
 }

hazelcast/pom.xml

@@ -22,7 +22,7 @@
         <dependency>
             <groupId>com.hazelcast</groupId>
             <artifactId>hazelcast-client</artifactId>
-            <version>3.7.2</version>
+            <version>${hazelcast.version}</version>
         </dependency>
 
     </dependencies>
@@ -39,7 +39,7 @@
 
     <properties>
         <!-- hazelcast -->
-        <hazelcast.version>3.7.4</hazelcast.version>
+        <hazelcast.version>3.8.4</hazelcast.version>
     </properties>
 
 </project>

hbase/pom.xml

@@ -31,7 +31,7 @@
     </dependencies>
 
     <properties>
-        <hbase.version>1.3.0</hbase.version>
+        <hbase.version>1.3.1</hbase.version>
     </properties>