Merge pull request #5 from eugenp/master

Merge

.gitignore

@@ -56,4 +56,9 @@ core-java-io/hard_link.txt
 core-java-io/target_link.txt
 core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
 ethereum/logs/
-jmeter/src/main/resources/*-JMeter.csv
+jmeter/src/main/resources/*-JMeter.csv
+
+**/node_modules/
+**/dist
+**/tmp
+**/out-tsc

core-java-8/README.md

@@ -56,3 +56,4 @@
 - [Generalized Target-Type Inference in Java](http://www.baeldung.com/java-generalized-target-type-inference)
 - [Image to Base64 String Conversion](http://www.baeldung.com/java-base64-image-string)
 - [Calculate Age in Java](http://www.baeldung.com/java-get-age)
+- [Add Hours To a Date In Java](http://www.baeldung.com/java-add-hours-date)

core-java-8/src/main/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingCommonsEmptyIfNull.java

@@ -0,0 +1,19 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+import static org.apache.commons.collections4.CollectionUtils.emptyIfNull;
+
+public class NullSafeCollectionStreamsUsingCommonsEmptyIfNull {
+
+    /**
+    * This method shows how to make a null safe stream from a collection through the use of 
+    * emptyIfNull() method from Apache Commons CollectionUtils library
+    * 
+     * @param collection The collection that is to be converted into a stream
+     * @return The stream that has been created from the collection or an empty stream if the collection is null
+    */
+    public Stream<String> collectionAsStream(Collection<String> collection) {
+        return emptyIfNull(collection).stream();
+    }
+}

core-java-8/src/main/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingJava8OptionalContainer.java

@@ -0,0 +1,21 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class NullSafeCollectionStreamsUsingJava8OptionalContainer {
+
+    /**
+    * This method shows how to make a null safe stream from a collection  through the use of 
+    * Java SE 8’s Optional Container
+    * 
+     * @param collection The collection that is to be converted into a stream
+     * @return The stream that has been created from the collection or an empty stream if the collection is null
+    */
+    public Stream<String> collectionAsStream(Collection<String> collection) {
+        return Optional.ofNullable(collection)
+            .map(Collection::stream)
+            .orElseGet(Stream::empty);
+    }
+}

core-java-8/src/main/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingNullDereferenceCheck.java

@@ -0,0 +1,20 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+
+public class NullSafeCollectionStreamsUsingNullDereferenceCheck {
+    
+    /**
+    * This method shows how to make a null safe stream from a collection through the use of a check 
+    * to prevent null dereferences
+    * 
+    * @param collection The collection that is to be converted into a stream
+    * @return The stream that has been created from the collection or an empty stream if the collection is null
+    */
+    public Stream<String> collectionAsStream(Collection<String> collection) {
+        return collection == null ? Stream.empty() : collection.stream();
+    }    
+
+
+}

core-java-8/src/test/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingCommonsEmptyIfNullUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.stream.Stream;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+
+public class NullSafeCollectionStreamsUsingCommonsEmptyIfNullUnitTest {
+
+    private final NullSafeCollectionStreamsUsingCommonsEmptyIfNull instance = 
+            new NullSafeCollectionStreamsUsingCommonsEmptyIfNull();
+
+    @Test
+    public void whenCollectionIsNull_thenExpectAnEmptyStream() {
+        Collection<String> collection = null;
+        Stream<String> expResult = Stream.empty();
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+
+    }
+
+    @Test
+    public void whenCollectionHasElements_thenExpectAStreamOfExactlyTheSameElements() {
+
+        Collection<String> collection = Arrays.asList("a", "b", "c");
+        Stream<String> expResult = Arrays.stream(new String[] { "a", "b", "c" });
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+    }
+
+    private static void assertStreamEquals(Stream<?> s1, Stream<?> s2) {
+        Iterator<?> iter1 = s1.iterator(), iter2 = s2.iterator();
+        while (iter1.hasNext() && iter2.hasNext())
+            assertEquals(iter1.next(), iter2.next());
+        assert !iter1.hasNext() && !iter2.hasNext();
+    }
+    
+}

core-java-8/src/test/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingJava8OptionalContainerUnitTest.java

@@ -0,0 +1,53 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.stream.Stream;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Kwaje Anthony <[email protected]>
+ */
+public class NullSafeCollectionStreamsUsingJava8OptionalContainerUnitTest {
+    
+    private final NullSafeCollectionStreamsUsingJava8OptionalContainer instance = 
+            new NullSafeCollectionStreamsUsingJava8OptionalContainer();
+
+    @Test
+    public void whenCollectionIsNull_thenExpectAnEmptyStream() {
+        Collection<String> collection = null;
+        Stream<String> expResult = Stream.empty();
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+
+    }
+
+    @Test
+    public void whenCollectionHasElements_thenExpectAStreamOfExactlyTheSameElements() {
+
+        Collection<String> collection = Arrays.asList("a", "b", "c");
+        Stream<String> expResult = Arrays.stream(new String[] { "a", "b", "c" });
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+    }
+
+    private static void assertStreamEquals(Stream<?> s1, Stream<?> s2) {
+        Iterator<?> iter1 = s1.iterator(), iter2 = s2.iterator();
+        while (iter1.hasNext() && iter2.hasNext())
+            assertEquals(iter1.next(), iter2.next());
+        assert !iter1.hasNext() && !iter2.hasNext();
+    }
+    
+}

core-java-8/src/test/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingNullDereferenceCheckUnitTest.java

@@ -0,0 +1,45 @@
+
+package com.baeldung.nullsafecollectionstreams;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.stream.Stream;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Kwaje Anthony <[email protected]>
+ */
+public class NullSafeCollectionStreamsUsingNullDereferenceCheckUnitTest {
+
+    private final NullSafeCollectionStreamsUsingNullDereferenceCheck instance = 
+            new NullSafeCollectionStreamsUsingNullDereferenceCheck();
+
+    @Test
+    public void whenCollectionIsNull_thenExpectAnEmptyStream() {
+        Collection<String> collection = null;
+        Stream<String> expResult = Stream.empty();
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+
+    }
+
+    @Test
+    public void whenCollectionHasElements_thenExpectAStreamOfExactlyTheSameElements() {
+
+        Collection<String> collection = Arrays.asList("a", "b", "c");
+        Stream<String> expResult = Arrays.stream(new String[] { "a", "b", "c" });
+        Stream<String> result = instance.collectionAsStream(collection);
+        assertStreamEquals(expResult, result);
+    }
+
+    private static void assertStreamEquals(Stream<?> s1, Stream<?> s2) {
+        Iterator<?> iter1 = s1.iterator(), iter2 = s2.iterator();
+        while (iter1.hasNext() && iter2.hasNext())
+            assertEquals(iter1.next(), iter2.next());
+        assert !iter1.hasNext() && !iter2.hasNext();
+    }
+
+}

core-java-collections/pom.xml

@@ -36,11 +36,6 @@
             <artifactId>commons-lang3</artifactId>
             <version>${commons-lang3.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.eclipse.collections</groupId>
-            <artifactId>eclipse-collections-api</artifactId>
-            <version>${eclipse.collections.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.eclipse.collections</groupId>
             <artifactId>eclipse-collections</artifactId>

core-java-collections/src/main/java/com/baeldung/list/removeall/RemoveAll.java

@@ -0,0 +1,111 @@
+package com.baeldung.list.removeall;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class RemoveAll {
+
+    static void removeWithWhileLoopPrimitiveElement(List<Integer> list, int element) {
+        while (list.contains(element)) {
+            list.remove(element);
+        }
+    }
+
+    static void removeWithWhileLoopNonPrimitiveElement(List<Integer> list, Integer element) {
+        while (list.contains(element)) {
+            list.remove(element);
+        }
+    }
+
+    static void removeWithWhileLoopStoringFirstOccurrenceIndex(List<Integer> list, Integer element) {
+        int index;
+        while ((index = list.indexOf(element)) >= 0) {
+            list.remove(index);
+        }
+    }
+
+    static void removeWithCallingRemoveUntilModifies(List<Integer> list, Integer element) {
+        while (list.remove(element))
+            ;
+    }
+
+    static void removeWithStandardForLoopUsingIndex(List<Integer> list, int element) {
+        for (int i = 0; i < list.size(); i++) {
+            if (Objects.equals(element, list.get(i))) {
+                list.remove(i);
+            }
+        }
+    }
+
+    static void removeWithForLoopDecrementOnRemove(List<Integer> list, int element) {
+        for (int i = 0; i < list.size(); i++) {
+            if (Objects.equals(element, list.get(i))) {
+                list.remove(i);
+                i--;
+            }
+        }
+    }
+
+    static void removeWithForLoopIncrementIfRemains(List<Integer> list, int element) {
+        for (int i = 0; i < list.size();) {
+            if (Objects.equals(element, list.get(i))) {
+                list.remove(i);
+            } else {
+                i++;
+            }
+        }
+    }
+
+    static void removeWithForEachLoop(List<Integer> list, int element) {
+        for (Integer number : list) {
+            if (Objects.equals(number, element)) {
+                list.remove(number);
+            }
+        }
+    }
+
+    static void removeWithIterator(List<Integer> list, int element) {
+        for (Iterator<Integer> i = list.iterator(); i.hasNext();) {
+            Integer number = i.next();
+            if (Objects.equals(number, element)) {
+                i.remove();
+            }
+        }
+    }
+
+    static List<Integer> removeWithCollectingAndReturningRemainingElements(List<Integer> list, int element) {
+        List<Integer> remainingElements = new ArrayList<>();
+        for (Integer number : list) {
+            if (!Objects.equals(number, element)) {
+                remainingElements.add(number);
+            }
+        }
+        return remainingElements;
+    }
+
+    static void removeWithCollectingRemainingElementsAndAddingToOriginalList(List<Integer> list, int element) {
+        List<Integer> remainingElements = new ArrayList<>();
+        for (Integer number : list) {
+            if (!Objects.equals(number, element)) {
+                remainingElements.add(number);
+            }
+        }
+
+        list.clear();
+        list.addAll(remainingElements);
+    }
+
+    static List<Integer> removeWithStreamFilter(List<Integer> list, Integer element) {
+        return list.stream()
+            .filter(e -> !Objects.equals(e, element))
+            .collect(Collectors.toList());
+    }
+
+    static void removeWithRemoveIf(List<Integer> list, Integer element) {
+        list.removeIf(n -> Objects.equals(n, element));
+    }
+
+}

core-java-collections/src/main/java/com/baeldung/thread_safe_lifo/DequeBasedSynchronizedStack.java

@@ -0,0 +1,36 @@
+package com.baeldung.thread_safe_lifo;
+
+import java.util.ArrayDeque;
+
+/**
+ * Deque Based Stack implementation.
+ */
+public class DequeBasedSynchronizedStack<T> {
+
+    // Internal Deque which gets decorated for synchronization.
+    private ArrayDeque<T> dequeStore = new ArrayDeque<>();
+
+    public DequeBasedSynchronizedStack(int initialCapacity) {
+        this.dequeStore = new ArrayDeque<>(initialCapacity);
+    }
+
+    public DequeBasedSynchronizedStack() {
+
+    }
+
+    public synchronized T pop() {
+        return this.dequeStore.pop();
+    }
+
+    public synchronized void push(T element) {
+        this.dequeStore.push(element);
+    }
+
+    public synchronized T peek() {
+        return this.dequeStore.peek();
+    }
+
+    public synchronized int size() {
+        return this.dequeStore.size();
+    }
+}

core-java-collections/src/test/java/com/baeldung/list/removeall/RemoveAllUnitTest.java

@@ -0,0 +1,210 @@
+package com.baeldung.list.removeall;
+
+import static com.baeldung.list.removeall.RemoveAll.removeWithCallingRemoveUntilModifies;
+import static com.baeldung.list.removeall.RemoveAll.removeWithCollectingAndReturningRemainingElements;
+import static com.baeldung.list.removeall.RemoveAll.removeWithCollectingRemainingElementsAndAddingToOriginalList;
+import static com.baeldung.list.removeall.RemoveAll.removeWithForEachLoop;
+import static com.baeldung.list.removeall.RemoveAll.removeWithForLoopDecrementOnRemove;
+import static com.baeldung.list.removeall.RemoveAll.removeWithForLoopIncrementIfRemains;
+import static com.baeldung.list.removeall.RemoveAll.removeWithIterator;
+import static com.baeldung.list.removeall.RemoveAll.removeWithRemoveIf;
+import static com.baeldung.list.removeall.RemoveAll.removeWithStandardForLoopUsingIndex;
+import static com.baeldung.list.removeall.RemoveAll.removeWithStreamFilter;
+import static com.baeldung.list.removeall.RemoveAll.removeWithWhileLoopNonPrimitiveElement;
+import static com.baeldung.list.removeall.RemoveAll.removeWithWhileLoopPrimitiveElement;
+import static com.baeldung.list.removeall.RemoveAll.removeWithWhileLoopStoringFirstOccurrenceIndex;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.ConcurrentModificationException;
+import java.util.List;
+
+import org.junit.Test;
+
+public class RemoveAllUnitTest {
+
+	private List<Integer> list(Integer... elements) {
+		return new ArrayList<>(Arrays.asList(elements));
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithWhileLoopUsingPrimitiveElement_thenTheResultCorrect() {
+		// given
+		List<Integer> list = list(1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		assertThatThrownBy(() -> removeWithWhileLoopPrimitiveElement(list, valueToRemove))
+				.isInstanceOf(IndexOutOfBoundsException.class);
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithWhileLoopUsingNonPrimitiveElement_thenTheResultCorrect() {
+		// given
+		List<Integer> list = list(1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithWhileLoopNonPrimitiveElement(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithWhileLoopStoringFirstOccurrenceIndex_thenTheResultCorrect() {
+		// given
+		List<Integer> list = list(1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithWhileLoopStoringFirstOccurrenceIndex(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithCallingRemoveUntilModifies_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithCallingRemoveUntilModifies(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAListWithoutDuplication_whenRemovingElementsWithStandardForLoopUsingIndex_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithStandardForLoopUsingIndex(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAListWithAdjacentElements_whenRemovingElementsWithStandardForLoop_thenTheResultIsInCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithStandardForLoopUsingIndex(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(1, 2, 3));
+	}
+
+	@Test
+	public void givenAListWithAdjacentElements_whenRemovingElementsWithForLoopAndDecrementOnRemove_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithForLoopDecrementOnRemove(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAListWithAdjacentElements_whenRemovingElementsWithForLoopAndIncrementIfRemains_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithForLoopIncrementIfRemains(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithForEachLoop_thenExceptionIsThrown() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		assertThatThrownBy(() -> removeWithForEachLoop(list, valueToRemove))
+				.isInstanceOf(ConcurrentModificationException.class);
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithIterator_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithIterator(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithCollectingAndReturningRemainingElements_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		List<Integer> result = removeWithCollectingAndReturningRemainingElements(list, valueToRemove);
+
+		// then
+		assertThat(result).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithCollectingRemainingAndAddingToOriginalList_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithCollectingRemainingElementsAndAddingToOriginalList(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithStreamFilter_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		List<Integer> result = removeWithStreamFilter(list, valueToRemove);
+
+		// then
+		assertThat(result).isEqualTo(list(2, 3));
+	}
+
+	@Test
+	public void givenAList_whenRemovingElementsWithCallingRemoveIf_thenTheResultIsCorrect() {
+		// given
+		List<Integer> list = list(1, 1, 2, 3);
+		int valueToRemove = 1;
+
+		// when
+		removeWithRemoveIf(list, valueToRemove);
+
+		// then
+		assertThat(list).isEqualTo(list(2, 3));
+	}
+
+}

core-java-collections/src/test/java/com/baeldung/stack_tests/MultithreadingCorrectnessStackUnitTest.java

@@ -0,0 +1,101 @@
+package com.baeldung.stack_tests;
+
+import com.baeldung.thread_safe_lifo.DequeBasedSynchronizedStack;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayDeque;
+import java.util.concurrent.ConcurrentLinkedDeque;
+
+import static java.util.stream.IntStream.range;
+
+/**
+ * Correctness tests for Stack in multi threaded environment.
+ */
+public class MultithreadingCorrectnessStackUnitTest {
+
+    @Test
+    public void givenSynchronizedDeque_whenExecutedParallel_thenWorkRight() {
+
+        DequeBasedSynchronizedStack<Integer> deque = new DequeBasedSynchronizedStack<>();
+
+        // Serial execution of push on ConcurrentLinkedQueue will always result in correct execution.
+        range(1, 10000).forEach(value -> deque.push(value));
+
+        int sum = 0;
+        while(deque.peek() != null) {
+            sum += deque.pop();
+        }
+
+        Assert.assertEquals(49995000, sum);
+
+        // Parallel execution of push on ConcurrentLinkedQueue will always result in correct execution.
+        range(1, 10000).parallel().forEach(value -> deque.push(value));
+
+        sum = 0;
+        while(deque.peek() != null) {
+            sum += deque.pop();
+        }
+
+        Assert.assertEquals(49995000, sum);
+    }
+
+    @Test
+    public void givenConcurrentLinkedQueue_whenExecutedParallel_thenWorkRight() {
+
+        ConcurrentLinkedDeque<Integer> deque = new ConcurrentLinkedDeque<>();
+
+        // Serial execution of push on ConcurrentLinkedQueue will always result in correct execution.
+        range(1, 10000).forEach(value -> deque.push(value));
+
+        int sum = 0;
+        while(deque.peek() != null) {
+            sum += deque.pop();
+        }
+
+        Assert.assertEquals(49995000, sum);
+
+        // Parallel execution of push on ConcurrentLinkedQueue will always result in correct execution.
+        range(1, 10000).parallel().forEach(value -> deque.push(value));
+
+        sum = 0;
+        while(deque.peek() != null) {
+            sum += deque.pop();
+        }
+
+        Assert.assertEquals(49995000, sum);
+    }
+
+    @Test
+    public void givenArrayDeque_whenExecutedParallel_thenShouldFail() {
+
+        ArrayDeque<Integer> deque = new ArrayDeque<>();
+
+        // Serial execution of push on ArrayDeque will always result in correct execution.
+        range(1, 10000).forEach(value -> deque.push(value));
+
+        int sum = 0;
+        while(deque.peek() != null) {
+            sum += deque.pop();
+        }
+
+        Assert.assertEquals(49995000, sum);
+
+        // Parallel execution of push on ArrayDeque will not result in correct execution.
+        range(1, 10000).parallel().forEach(value -> deque.push(value));
+
+        sum = 0;
+        while(deque.peek() != null) {
+            sum += deque.pop();
+        }
+
+        // This shouldn't happen.
+        if(sum == 49995000) {
+            System.out.println("Something wrong in the environment, Please try some big value and check");
+            // To safe-guard build without test failures.
+            return;
+        }
+
+        Assert.assertNotEquals(49995000, sum);
+    }
+}

core-java-collections/src/test/java/com/baeldung/stack_tests/StackUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.stack_tests;
+
+import com.baeldung.thread_safe_lifo.DequeBasedSynchronizedStack;
+import com.google.common.collect.Streams;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Stack;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.stream.Stream;
+
+import static java.util.stream.IntStream.range;
+
+/**
+ * These tests are to understand the Stack implementation in Java Collections.
+ */
+public class StackUnitTest {
+
+    @Test
+    public void givenStack_whenPushPopPeek_thenWorkRight() {
+        Stack<String> namesStack = new Stack<>();
+
+        namesStack.push("Bill Gates");
+        namesStack.push("Elon Musk");
+
+        Assert.assertEquals("Elon Musk", namesStack.peek());
+        Assert.assertEquals("Elon Musk", namesStack.pop());
+        Assert.assertEquals("Bill Gates", namesStack.pop());
+
+        Assert.assertEquals(0, namesStack.size());
+    }
+
+    @Test
+    public void givenSynchronizedDeque_whenPushPopPeek_thenWorkRight() {
+        DequeBasedSynchronizedStack<String> namesStack = new DequeBasedSynchronizedStack<>();
+
+        namesStack.push("Bill Gates");
+        namesStack.push("Elon Musk");
+
+        Assert.assertEquals("Elon Musk", namesStack.peek());
+        Assert.assertEquals("Elon Musk", namesStack.pop());
+        Assert.assertEquals("Bill Gates", namesStack.pop());
+
+        Assert.assertEquals(0, namesStack.size());
+    }
+
+    @Test
+    public void givenConcurrentLinkedDeque_whenPushPopPeek_thenWorkRight() {
+        ConcurrentLinkedDeque<String> namesStack = new ConcurrentLinkedDeque<>();
+
+        namesStack.push("Bill Gates");
+        namesStack.push("Elon Musk");
+
+        Assert.assertEquals("Elon Musk", namesStack.peek());
+        Assert.assertEquals("Elon Musk", namesStack.pop());
+        Assert.assertEquals("Bill Gates", namesStack.pop());
+
+        Assert.assertEquals(0, namesStack.size());
+    }
+}

core-java-io/src/test/java/com/baeldung/file/FilenameFilterManualTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.file;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class FilenameFilterManualTest {
+
+    private static File directory;
+
+    @BeforeClass
+    public static void setupClass() {
+        directory = new File(FilenameFilterManualTest.class.getClassLoader()
+            .getResource("testFolder")
+            .getFile());
+    }
+
+    @Test
+    public void whenFilteringFilesEndingWithJson_thenEqualExpectedFiles() {
+        FilenameFilter filter = (dir, name) -> name.endsWith(".json");
+
+        String[] expectedFiles = { "people.json", "students.json" };
+        String[] actualFiles = directory.list(filter);
+
+        Assert.assertArrayEquals(expectedFiles, actualFiles);
+    }
+
+    @Test
+    public void whenFilteringFilesEndingWithXml_thenEqualExpectedFiles() {
+        Predicate<String> predicate = (name) -> name.endsWith(".xml");
+
+        String[] expectedFiles = { "teachers.xml", "workers.xml" };
+        List<String> files = Arrays.stream(directory.list())
+            .filter(predicate)
+            .collect(Collectors.toList());
+        String[] actualFiles = files.toArray(new String[files.size()]);
+
+        Assert.assertArrayEquals(expectedFiles, actualFiles);
+    }
+
+}

core-java-io/src/test/resources/testFolder/people.json

@@ -0,0 +1 @@
+{}

core-java-io/src/test/resources/testFolder/students.json

@@ -0,0 +1 @@
+{}

core-java-io/src/test/resources/testFolder/teachers.xml

@@ -0,0 +1 @@
+<xml></xml>

core-java-io/src/test/resources/testFolder/workers.xml

@@ -0,0 +1 @@
+<xml></xml>

core-java/src/main/java/com/baeldung/exceptionhandling/Exceptions.java

@@ -0,0 +1,212 @@
+package com.baeldung.exceptionhandling;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Scanner;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+public class Exceptions {
+
+    private final static Logger logger = Logger.getLogger("ExceptionLogging");
+
+    public static List<Player> getPlayers() throws IOException {
+        Path path = Paths.get("players.dat");
+        List<String> players = Files.readAllLines(path);
+
+        return players.stream()
+          .map(Player::new)
+          .collect(Collectors.toList());
+    }
+
+    public List<Player> loadAllPlayers(String playersFile) throws IOException{
+        try {
+            throw new IOException();
+        } catch(IOException ex) {
+            throw new IllegalStateException();
+        }
+    }
+
+    public int getPlayerScoreThrows(String playerFile) throws FileNotFoundException {		 
+        Scanner contents = new Scanner(new File(playerFile));
+        return Integer.parseInt(contents.nextLine());
+    }
+
+    public int getPlayerScoreTryCatch(String playerFile) {
+        try {
+            Scanner contents = new Scanner(new File(playerFile));
+            return Integer.parseInt(contents.nextLine());
+        } catch (FileNotFoundException noFile) {
+            throw new IllegalArgumentException("File not found");
+        }
+    }
+
+    public int getPlayerScoreTryCatchRecovery(String playerFile) {
+        try {
+            Scanner contents = new Scanner(new File(playerFile));
+            return Integer.parseInt(contents.nextLine());
+        } catch ( FileNotFoundException noFile ) {
+            logger.warning("File not found, resetting score.");
+            return 0;
+        }
+    }
+
+    public int getPlayerScoreFinally(String playerFile) throws FileNotFoundException {
+        Scanner contents = null;
+        try {
+            contents = new Scanner(new File(playerFile));
+            return Integer.parseInt(contents.nextLine());
+        } finally {
+            if (contents != null) {
+                contents.close();
+            }
+        }
+    }
+
+    public int getPlayerScoreTryWithResources(String playerFile) {
+        try (Scanner contents = new Scanner(new File(playerFile))) {
+            return Integer.parseInt(contents.nextLine());
+        } catch (FileNotFoundException e ) {
+            logger.warning("File not found, resetting score.");
+            return 0;
+        }
+    }
+
+    public int getPlayerScoreMultipleCatchBlocks(String playerFile) {
+        try (Scanner contents = new Scanner(new File(playerFile))) {
+            return Integer.parseInt(contents.nextLine());
+        } catch (IOException e) {
+            logger.warning("Player file wouldn't load!");
+            return 0;
+        } catch (NumberFormatException e) {
+            logger.warning("Player file was corrupted!");
+            return 0;
+        }
+    }
+
+    public int getPlayerScoreMultipleCatchBlocksAlternative(String playerFile) {
+        try (Scanner contents = new Scanner(new File(playerFile)) ) {
+            return Integer.parseInt(contents.nextLine());
+        } catch (FileNotFoundException e) {
+            logger.warning("Player file not found!");
+            return 0;
+        } catch (IOException e) {
+            logger.warning("Player file wouldn't load!");
+            return 0;
+        } catch (NumberFormatException e) {
+            logger.warning("Player file was corrupted!");
+            return 0;
+        }
+    }
+
+    public int getPlayerScoreUnionCatchBlocks(String playerFile) {
+        try (Scanner contents = new Scanner(new File(playerFile))) {
+            return Integer.parseInt(contents.nextLine());
+        } catch (IOException | NumberFormatException e) {
+            logger.warning("Failed to load score!");
+            return 0;
+        }
+    }
+
+    public List<Player> loadAllPlayersThrowingChecked(String playersFile) throws TimeoutException {
+        boolean tooLong = true;
+
+        while (!tooLong) {
+            // ... potentially long operation
+        }
+            throw new TimeoutException("This operation took too long");
+    }
+
+    public List<Player> loadAllPlayersThrowingUnchecked(String playersFile) throws TimeoutException {
+        if(!isFilenameValid(playersFile)) {
+            throw new IllegalArgumentException("Filename isn't valid!");
+        }
+        return null;
+
+        // ...
+    }
+
+    public List<Player> loadAllPlayersWrapping(String playersFile) throws IOException {
+        try { 
+            throw new IOException();
+        } catch (IOException io) { 		
+            throw io;
+        }
+    }
+
+    public List<Player> loadAllPlayersRethrowing(String playersFile) throws PlayerLoadException {
+        try { 
+            throw new IOException();
+        } catch (IOException io) { 		
+            throw new PlayerLoadException(io);
+        }
+    }
+
+    public List<Player> loadAllPlayersThrowable(String playersFile) {
+        try {
+            throw new NullPointerException();
+        } catch ( Throwable t ) {
+            throw t;
+        }
+    }
+
+    class FewerExceptions extends Exceptions {
+        @Override
+        public List<Player> loadAllPlayers(String playersFile) {  //can't add "throws MyCheckedException 
+            return null;
+            // overridden
+        }
+    }
+
+    public void throwAsGotoAntiPattern() {
+        try {
+            // bunch of code
+            throw new MyException();
+            // second bunch of code
+        } catch ( MyException e ) {
+            // third bunch of code
+        }
+    }
+
+    public int getPlayerScoreSwallowingExceptionAntiPattern(String playerFile) {
+        try {
+        // ...
+        } catch (Exception e) {} // <== catch and swallow
+            return 0;
+    }
+
+    public int getPlayerScoreSwallowingExceptionAntiPatternAlternative(String playerFile) {
+        try {
+            // ...
+        } catch (Exception e) {
+             e.printStackTrace();
+        }
+      return 0;
+    }
+
+    public int getPlayerScoreSwallowingExceptionAntiPatternAlternative2(String playerFile) throws PlayerScoreException {
+        try {
+            throw new IOException();
+        } catch (IOException e) {
+            throw new PlayerScoreException(e);
+        }
+    }
+
+    public int getPlayerScoreReturnInFinallyAntiPattern(String playerFile) {
+        int score = 0;
+        try {
+            throw new IOException();
+        } finally {
+            return score; // <== the IOException is dropped
+        }
+    }
+
+    private boolean isFilenameValid(String name) {
+        return false;
+    }
+}

core-java/src/main/java/com/baeldung/exceptionhandling/MyException.java

@@ -0,0 +1,5 @@
+package com.baeldung.exceptionhandling;
+
+public class MyException extends Throwable {
+
+}

core-java/src/main/java/com/baeldung/exceptionhandling/Player.java

@@ -0,0 +1,12 @@
+package com.baeldung.exceptionhandling;
+
+public class Player {
+
+    public int id;
+    public String name;
+
+    public Player(String name) {
+        this.name = name;
+    }
+
+}

core-java/src/main/java/com/baeldung/exceptionhandling/PlayerLoadException.java

@@ -0,0 +1,11 @@
+package com.baeldung.exceptionhandling;
+
+import java.io.IOException;
+
+public class PlayerLoadException extends Exception {
+
+    public PlayerLoadException(IOException io) {
+        super(io);
+    }
+
+}

core-java/src/main/java/com/baeldung/exceptionhandling/PlayerScoreException.java

@@ -0,0 +1,8 @@
+package com.baeldung.exceptionhandling;
+
+public class PlayerScoreException extends Exception {
+
+    public PlayerScoreException(Exception e) {
+        super(e);
+    }
+}

core-java/src/main/java/com/baeldung/exceptionhandling/TimeoutException.java

@@ -0,0 +1,8 @@
+package com.baeldung.exceptionhandling;
+
+public class TimeoutException extends Exception {
+
+    public TimeoutException(String message) {
+        super(message);
+    }
+}

core-java/src/main/java/com/baeldung/objectsize/InstrumentationAgent.java

@@ -0,0 +1,18 @@
+package com.baeldung.objectsize;
+
+import java.lang.instrument.Instrumentation;
+
+public class InstrumentationAgent {
+    private static volatile Instrumentation globalInstrumentation;
+
+    public static void premain(final String agentArgs, final Instrumentation inst) {
+        globalInstrumentation = inst;
+    }
+
+    public static long getObjectSize(final Object object) {
+        if (globalInstrumentation == null) {
+            throw new IllegalStateException("Agent not initialized.");
+        }
+        return globalInstrumentation.getObjectSize(object);
+    }
+}