[BAEL-9555] - Created a core-java-modules folder

core-java-modules/core-java-collections/src/test/java/com/baeldung/arraydeque/ArrayDequeUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.arraydeque;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+public class ArrayDequeUnitTest {
+
+    @Test
+    public void whenOffer_addsAtLast() {
+        final Deque<String> deque = new ArrayDeque<>();
+
+        deque.offer("first");
+        deque.offer("second");
+
+        assertEquals("second", deque.getLast());
+    }
+
+    @Test
+    public void whenPoll_removesFirst() {
+        final Deque<String> deque = new ArrayDeque<>();
+
+        deque.offer("first");
+        deque.offer("second");
+
+        assertEquals("first", deque.poll());
+    }
+
+    @Test
+    public void whenPush_addsAtFirst() {
+        final Deque<String> deque = new ArrayDeque<>();
+
+        deque.push("first");
+        deque.push("second");
+
+        assertEquals("second", deque.getFirst());
+    }
+
+    @Test
+    public void whenPop_removesLast() {
+        final Deque<String> deque = new ArrayDeque<>();
+
+        deque.push("first");
+        deque.push("second");
+
+        assertEquals("second", deque.pop());
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/charstack/CharStackUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.charstack;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class CharStackUnitTest {
+
+    @Test
+    public void whenCharStackIsCreated_thenItHasSize0() {
+
+        CharStack charStack = new CharStack();
+
+        assertEquals(0, charStack.size());
+    }
+
+    @Test
+    public void givenEmptyCharStack_whenElementIsPushed_thenStackSizeisIncreased() {
+
+        CharStack charStack = new CharStack();
+
+        charStack.push('A');
+
+        assertEquals(1, charStack.size());
+    }
+
+    @Test
+    public void givenCharStack_whenElementIsPoppedFromStack_thenElementIsRemovedAndSizeChanges() {
+
+        CharStack charStack = new CharStack();
+        charStack.push('A');
+
+        char element = charStack.pop();
+
+        assertEquals('A', element);
+        assertEquals(0, charStack.size());
+    }
+
+    @Test
+    public void givenCharStack_whenElementIsPeeked_thenElementIsNotRemovedAndSizeDoesNotChange() {
+        CharStack charStack = new CharStack();
+        charStack.push('A');
+
+        char element = charStack.peek();
+
+        assertEquals('A', element);
+        assertEquals(1, charStack.size());
+    }
+
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/charstack/CharStackUsingJavaUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.charstack;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Stack;
+
+import org.junit.jupiter.api.Test;
+
+public class CharStackUsingJavaUnitTest {
+
+    @Test
+    public void whenCharStackIsCreated_thenItHasSize0() {
+
+        Stack<Character> charStack = new Stack<>();
+
+        assertEquals(0, charStack.size());
+    }
+
+    @Test
+    public void givenEmptyCharStack_whenElementIsPushed_thenStackSizeisIncreased() {
+
+        Stack<Character> charStack = new Stack<>();
+
+        charStack.push('A');
+
+        assertEquals(1, charStack.size());
+    }
+
+    @Test
+    public void givenCharStack_whenElementIsPoppedFromStack_thenElementIsRemovedAndSizeChanges() {
+
+        Stack<Character> charStack = new Stack<>();
+        charStack.push('A');
+
+        char element = charStack.pop();
+
+        assertEquals('A', element);
+        assertEquals(0, charStack.size());
+    }
+
+    @Test
+    public void givenCharStack_whenElementIsPeeked_thenElementIsNotRemovedAndSizeDoesNotChange() {
+
+        Stack<Character> charStack = new Stack<>();
+        charStack.push('A');
+
+        char element = charStack.peek();
+
+        assertEquals('A', element);
+        assertEquals(1, charStack.size());
+    }
+
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/charstack/CharStackWithArrayUnitTest.java

@@ -0,0 +1,65 @@
+package com.baeldung.charstack;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class CharStackWithArrayUnitTest {
+
+    @Test
+    public void whenCharStackIsCreated_thenItHasSize0() {
+
+        CharStackWithArray charStack = new CharStackWithArray();
+
+        assertEquals(0, charStack.size());
+    }
+
+    @Test
+    public void givenEmptyCharStack_whenElementIsPushed_thenStackSizeisIncreased() {
+
+        CharStackWithArray charStack = new CharStackWithArray();
+
+        charStack.push('A');
+
+        assertEquals(1, charStack.size());
+    }
+
+    @Test
+    public void givenEmptyCharStack_when5ElementIsPushed_thenStackSizeis() {
+
+        CharStackWithArray charStack = new CharStackWithArray();
+
+        charStack.push('A');
+        charStack.push('B');
+        charStack.push('C');
+        charStack.push('D');
+        charStack.push('E');
+
+        assertEquals(5, charStack.size());
+    }
+
+    @Test
+    public void givenCharStack_whenElementIsPoppedFromStack_thenElementIsRemovedAndSizeChanges() {
+
+        CharStackWithArray charStack = new CharStackWithArray();
+        charStack.push('A');
+
+        char element = charStack.pop();
+
+        assertEquals('A', element);
+        assertEquals(0, charStack.size());
+    }
+
+    @Test
+    public void givenCharStack_whenElementIsPeeked_thenElementIsNotRemovedAndSizeDoesNotChange() {
+
+        CharStackWithArray charStack = new CharStackWithArray();
+        charStack.push('A');
+
+        char element = charStack.peek();
+
+        assertEquals('A', element);
+        assertEquals(1, charStack.size());
+    }
+
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/combiningcollections/CombiningArraysUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.combiningcollections;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+public class CombiningArraysUnitTest {
+    private static final String first[] = {
+            "One", 
+            "Two", 
+            "Three"
+    };
+    
+    private static final String second[] = {
+            "Four", 
+            "Five", 
+            "Six"
+    };
+
+    private static final String expected[] = {
+            "One", 
+            "Two", 
+            "Three",
+            "Four", 
+            "Five", 
+            "Six"
+    };
+    
+    @Test
+    public void givenTwoArrays_whenUsingNativeJava_thenArraysCombined() {
+        assertArrayEquals(expected, CombiningArrays.usingNativeJava(first, second));
+    }
+
+    @Test
+    public void givenTwoArrays_whenUsingObjectStreams_thenArraysCombined() {
+        assertArrayEquals(expected, CombiningArrays.usingJava8ObjectStream(first, second));
+    }
+
+    @Test
+    public void givenTwoArrays_whenUsingFlatMaps_thenArraysCombined() {
+        assertArrayEquals(expected, CombiningArrays.usingJava8FlatMaps(first, second));
+    }
+
+    @Test
+    public void givenTwoArrays_whenUsingApacheCommons_thenArraysCombined() {
+        assertArrayEquals(expected, CombiningArrays.usingApacheCommons(first, second));
+    }
+
+    @Test
+    public void givenTwoArrays_whenUsingGuava_thenArraysCombined() {
+        assertArrayEquals(expected, CombiningArrays.usingGuava(first, second));
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/combiningcollections/CombiningListsUnitTest.java

@@ -0,0 +1,57 @@
+package com.baeldung.combiningcollections;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+
+public class CombiningListsUnitTest {
+    private static final List<Object> first = Arrays.asList(new Object[]{
+            "One", 
+            "Two", 
+            "Three"
+    });
+    
+    private static final List<Object> second = Arrays.asList(new Object[]{
+            "Four", 
+            "Five", 
+            "Six"
+    });
+
+    private static final List<Object> expected = Arrays.asList(new Object[]{
+            "One", 
+            "Two", 
+            "Three",
+            "Four", 
+            "Five", 
+            "Six"
+    });
+    
+    @Test
+    public void givenTwoLists_whenUsingNativeJava_thenArraysCombined() {
+    	assertThat(CombiningLists.usingNativeJava(first, second), is(expected));
+    }
+
+    @Test
+    public void givenTwoLists_whenUsingObjectStreams_thenArraysCombined() {
+        assertThat(CombiningLists.usingJava8ObjectStream(first, second), is(expected));
+    }
+
+    @Test
+    public void givenTwoLists_whenUsingFlatMaps_thenArraysCombined() {
+        assertThat(CombiningLists.usingJava8FlatMaps(first, second), is(expected));
+    }
+
+    @Test
+    public void givenTwoLists_whenUsingApacheCommons_thenArraysCombined() {
+        assertThat(CombiningLists.usingApacheCommons(first, second), is(expected));
+    }
+
+    @Test
+    public void givenTwoLists_whenUsingGuava_thenArraysCombined() {
+        assertThat(CombiningLists.usingGuava(first, second), is(expected));
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/combiningcollections/CombiningMapsUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.combiningcollections;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Test;
+
+public class CombiningMapsUnitTest {
+    private static final Map<String, String> first = new HashMap<>();
+    private static final Map<String, String> second = new HashMap<>();
+    private static Map<String, String> expected = new HashMap<>();
+    
+    static {
+    	first.put("one", "first String");
+    	first.put("two", "second String");
+    	
+    	second.put("three", "third String");
+    	second.put("four", "fourth String");
+
+    	expected.put("one", "first String");
+    	expected.put("two", "second String");
+    	expected.put("three", "third String");
+    	expected.put("four", "fourth String");
+    }
+    
+    @Test
+    public void givenTwoMaps_whenUsingNativeJava_thenMapsCombined() {
+    	assertThat(CombiningMaps.usingPlainJava(first, second), is(expected));
+    }
+
+    
+    @Test
+    public void givenTwoMaps_whenUsingForEach_thenMapsCombined() {
+    	assertThat(CombiningMaps.usingJava8ForEach(first, second), is(expected));
+    }
+    
+    @Test
+    public void givenTwoMaps_whenUsingFlatMaps_thenMapsCombined() {
+    	assertThat(CombiningMaps.usingJava8FlatMaps(first, second), is(expected));
+    }
+    
+    @Test
+    public void givenTwoMaps_whenUsingApacheCommons_thenMapsCombined() {
+    	assertThat(CombiningMaps.usingApacheCommons(first, second), is(expected));
+    }
+    
+    @Test
+    public void givenTwoMaps_whenUsingGuava_thenMapsCombined() {
+    	assertThat(CombiningMaps.usingGuava(first, second), is(expected));
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/combiningcollections/CombiningSetsUnitTest.java

@@ -0,0 +1,45 @@
+
+package com.baeldung.combiningcollections;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.Test;
+
+public class CombiningSetsUnitTest {
+	private static final Set<Object> first = new HashSet<Object>(Arrays.asList(new Object[] { "One", "Two", "Three" }));
+
+	private static final Set<Object> second = new HashSet<Object>(Arrays.asList(new Object[] { "Four", "Five", "Six" }));
+
+	private static final Set<Object> expected = new HashSet<Object>(Arrays
+			.asList(new Object[] { "One", "Two", "Three", "Four", "Five", "Six" }));
+
+	@Test
+	public void givenTwoSets_whenUsingNativeJava_thenArraysCombined() {
+		assertThat(CombiningSets.usingNativeJava(first, second), is(expected));
+	}
+
+	@Test
+	public void givenTwoSets_whenUsingObjectStreams_thenArraysCombined() {
+		assertThat(CombiningSets.usingJava8ObjectStream(first, second), is(expected));
+	}
+
+	@Test
+	public void givenTwoSets_whenUsingFlatMaps_thenArraysCombined() {
+		assertThat(CombiningSets.usingJava8FlatMaps(first, second), is(expected));
+	}
+
+	@Test
+	public void givenTwoSets_whenUsingApacheCommons_thenArraysCombined() {
+		assertThat(CombiningSets.usingApacheCommons(first, second), is(expected));
+	}
+
+	@Test
+	public void givenTwoSets_whenUsingGuava_thenArraysCombined() {
+		assertThat(CombiningSets.usingGuava(first, second), is(expected));
+	}
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/enummap/DummyEnum.java

@@ -0,0 +1,13 @@
+package com.baeldung.enummap;
+
+/**
+ * This enum is used for benchmarking, therefore has many values.
+ */
+public enum DummyEnum {
+    CCC_000,
+    CCC_001,CCC_002,CCC_003,CCC_004,CCC_005,CCC_006,CCC_007,CCC_008,CCC_009,CCC_010,
+    CCC_011,CCC_012,CCC_013,CCC_014,CCC_015,CCC_016,CCC_017,CCC_018,CCC_019,CCC_020,
+    CCC_021,CCC_022,CCC_023,CCC_024,CCC_025,CCC_026,CCC_027,CCC_028,CCC_029,CCC_030,
+    CCC_031,CCC_032,CCC_033,CCC_034,CCC_035,CCC_036,CCC_037,CCC_038,CCC_039,CCC_040,
+    CCC_041,CCC_042,CCC_043,CCC_044,CCC_045,CCC_046,CCC_047,CCC_048,CCC_049,
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/enummap/EnumMapBenchmarkLiveTest.java

@@ -0,0 +1,119 @@
+package com.baeldung.enummap;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode({ Mode.AverageTime })
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+public class EnumMapBenchmarkLiveTest {
+
+    @State(Scope.Thread)
+    public static class BenchmarkState {
+        EnumMap<DummyEnum, String> enumMap = new EnumMap<>(DummyEnum.class);
+        HashMap<DummyEnum, String> hashMap = new HashMap<>();
+        TreeMap<DummyEnum, String> treeMap = new TreeMap<>();
+        int len = DummyEnum.values().length;
+        Random random = new Random();
+        int randomIndex;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            DummyEnum[] values = DummyEnum.values();
+            for (int i = 0; i < len; i++) {
+                enumMap.put(values[i], values[i].toString());
+                hashMap.put(values[i], values[i].toString());
+                treeMap.put(values[i], values[i].toString());
+            }
+        }
+
+        @Setup(Level.Invocation)
+        public void additionalSetup() {
+            randomIndex = random.nextInt(len);
+        }
+
+    }
+
+    @Benchmark
+    public int benchmark01_EnumMapPut(BenchmarkState s) {
+        s.enumMap.put(DummyEnum.values()[s.randomIndex], DummyEnum.values()[s.randomIndex].toString());
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark01_HashMapPut(BenchmarkState s) {
+        s.hashMap.put(DummyEnum.values()[s.randomIndex], DummyEnum.values()[s.randomIndex].toString());
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark01_TreeMapPut(BenchmarkState s) {
+        s.treeMap.put(DummyEnum.values()[s.randomIndex], DummyEnum.values()[s.randomIndex].toString());
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark02_EnumMapGet(BenchmarkState s) {
+        s.enumMap.get(DummyEnum.values()[s.randomIndex]);
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark02_HashMapGet(BenchmarkState s) {
+        s.hashMap.get(DummyEnum.values()[s.randomIndex]);
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark02_TreeMapGet(BenchmarkState s) {
+        s.treeMap.get(DummyEnum.values()[s.randomIndex]);
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark03_EnumMapContainsKey(BenchmarkState s) {
+        s.enumMap.containsKey(DummyEnum.values()[s.randomIndex]);
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark03_HashMapContainsKey(BenchmarkState s) {
+        s.hashMap.containsKey(DummyEnum.values()[s.randomIndex]);
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark03_TreeMapContainsKey(BenchmarkState s) {
+        s.treeMap.containsKey(DummyEnum.values()[s.randomIndex]);
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark04_EnumMapContainsValue(BenchmarkState s) {
+        s.enumMap.containsValue(DummyEnum.values()[s.randomIndex].toString());
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark04_HashMapContainsValue(BenchmarkState s) {
+        s.hashMap.containsValue(DummyEnum.values()[s.randomIndex].toString());
+        return ++s.randomIndex;
+    }
+
+    @Benchmark
+    public int benchmark04_TreeMapContainsValue(BenchmarkState s) {
+        s.treeMap.containsValue(DummyEnum.values()[s.randomIndex].toString());
+        return ++s.randomIndex;
+    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder().include(EnumMapBenchmarkLiveTest.class.getSimpleName()).threads(1).forks(0).shouldFailOnError(true).shouldDoGC(false).jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/enummap/EnumMapUnitTest.java

@@ -0,0 +1,144 @@
+package com.baeldung.enummap;
+
+import org.junit.Test;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+import static java.util.AbstractMap.SimpleEntry;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+
+public class EnumMapUnitTest {
+    public enum DayOfWeek {
+        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
+    }
+
+    @Test
+    public void whenContructedWithEnumType_ThenOnlyAcceptThatAsKey() {
+        Map dayMap = new EnumMap<>(DayOfWeek.class);
+        assertThatCode(
+          () -> dayMap.put(TimeUnit.NANOSECONDS, "NANOSECONDS"))
+          .isInstanceOf(ClassCastException.class);
+    }
+
+    @Test
+    public void whenConstructedWithEnumMap_ThenSameKeyTypeAndInitialMappings() {
+        EnumMap<DayOfWeek, String> activityMap = new EnumMap<>(DayOfWeek.class);
+        activityMap.put(DayOfWeek.MONDAY, "Soccer");
+        activityMap.put(DayOfWeek.TUESDAY, "Basketball");
+
+        EnumMap<DayOfWeek, String> activityMapCopy = new EnumMap<>(activityMap);
+        assertThat(activityMapCopy.size()).isEqualTo(2);
+        assertThat(activityMapCopy.get(DayOfWeek.MONDAY))
+          .isEqualTo("Soccer");
+        assertThat(activityMapCopy.get(DayOfWeek.TUESDAY))
+          .isEqualTo("Basketball");
+    }
+
+    @Test
+    public void givenEmptyMap_whenConstructedWithMap_ThenException() {
+        HashMap ordinaryMap = new HashMap();
+        assertThatCode(() -> new EnumMap(ordinaryMap))
+          .isInstanceOf(IllegalArgumentException.class)
+          .hasMessage("Specified map is empty");
+    }
+
+    @Test
+    public void givenMapWithEntries_whenConstructedWithMap_ThenSucceed() {
+        HashMap<DayOfWeek, String> ordinaryMap = new HashMap<>();
+        ordinaryMap.put(DayOfWeek.MONDAY, "Soccer");
+        ordinaryMap.put(DayOfWeek.TUESDAY, "Basketball");
+        EnumMap<DayOfWeek, String> enumMap = new EnumMap<>(ordinaryMap);
+        assertThat(enumMap.size()).isEqualTo(2);
+        assertThat(enumMap.get(DayOfWeek.MONDAY)).isEqualTo("Soccer");
+        assertThat(enumMap.get(DayOfWeek.TUESDAY)).isEqualTo("Basketball");
+    }
+
+    @Test
+    public void givenMapWithMultiTypeEntries_whenConstructedWithMap_ThenException() {
+        HashMap<Enum, String> ordinaryMap = new HashMap<>();
+        ordinaryMap.put(DayOfWeek.MONDAY, "Soccer");
+        ordinaryMap.put(TimeUnit.MILLISECONDS, "Other enum type");
+        assertThatCode(() -> new EnumMap(ordinaryMap))
+          .isInstanceOf(ClassCastException.class);
+    }
+
+    @Test
+    public void whenPut_thenGet() {
+        Map<DayOfWeek, String> activityMap = new EnumMap(DayOfWeek.class);
+        activityMap.put(DayOfWeek.WEDNESDAY, "Hiking");
+        activityMap.put(DayOfWeek.THURSDAY, null);
+        assertThat(activityMap.get(DayOfWeek.WEDNESDAY)).isEqualTo("Hiking");
+        assertThat(activityMap.get(DayOfWeek.THURSDAY)).isNull();
+    }
+
+    @Test
+    public void givenMapping_whenContains_thenTrue() {
+        EnumMap<DayOfWeek, String> activityMap = new EnumMap(DayOfWeek.class);
+        assertThat(activityMap.containsKey(DayOfWeek.WEDNESDAY)).isFalse();
+        assertThat(activityMap.containsValue("Hiking")).isFalse();
+        activityMap.put(DayOfWeek.WEDNESDAY, "Hiking");
+        assertThat(activityMap.containsKey(DayOfWeek.WEDNESDAY)).isTrue();
+        assertThat(activityMap.containsValue("Hiking")).isTrue();
+
+        assertThat(activityMap.containsKey(DayOfWeek.SATURDAY)).isFalse();
+        assertThat(activityMap.containsValue(null)).isFalse();
+        activityMap.put(DayOfWeek.SATURDAY, null);
+        assertThat(activityMap.containsKey(DayOfWeek.SATURDAY)).isTrue();
+        assertThat(activityMap.containsValue(null)).isTrue();
+    }
+
+    @Test
+    public void whenRemove_thenRemoved() {
+        EnumMap<DayOfWeek, String> activityMap = new EnumMap(DayOfWeek.class);
+
+        activityMap.put(DayOfWeek.MONDAY, "Soccer");
+        assertThat(activityMap.remove(DayOfWeek.MONDAY)).isEqualTo("Soccer");
+        assertThat(activityMap.containsKey(DayOfWeek.MONDAY)).isFalse();
+
+        activityMap.put(DayOfWeek.MONDAY, "Soccer");
+        assertThat(activityMap.remove(DayOfWeek.MONDAY, "Hiking")).isEqualTo(false);
+        assertThat(activityMap.remove(DayOfWeek.MONDAY, "Soccer")).isEqualTo(true);
+    }
+
+    @Test
+    public void whenSubView_thenSubViewOrdered() {
+        EnumMap<DayOfWeek, String> activityMap = new EnumMap(DayOfWeek.class);
+        activityMap.put(DayOfWeek.THURSDAY, "Karate");
+        activityMap.put(DayOfWeek.WEDNESDAY, "Hiking");
+        activityMap.put(DayOfWeek.MONDAY, "Soccer");
+
+        Collection<String> values = activityMap.values();
+        assertThat(values).containsExactly("Soccer", "Hiking", "Karate");
+
+        Set<DayOfWeek> keys = activityMap.keySet();
+        assertThat(keys)
+          .containsExactly(DayOfWeek.MONDAY, DayOfWeek.WEDNESDAY,DayOfWeek.THURSDAY);
+
+        assertThat(activityMap.entrySet())
+          .containsExactly(
+            new SimpleEntry(DayOfWeek.MONDAY, "Soccer"),
+            new SimpleEntry(DayOfWeek.WEDNESDAY, "Hiking"),
+            new SimpleEntry(DayOfWeek.THURSDAY, "Karate"));
+    }
+
+    @Test
+    public void givenSubView_whenChange_thenReflected() {
+        EnumMap<DayOfWeek, String> activityMap = new EnumMap(DayOfWeek.class);
+        activityMap.put(DayOfWeek.THURSDAY, "Karate");
+        activityMap.put(DayOfWeek.WEDNESDAY, "Hiking");
+        activityMap.put(DayOfWeek.MONDAY, "Soccer");
+
+        Collection<String> values = activityMap.values();
+        assertThat(values).containsExactly("Soccer", "Hiking", "Karate");
+
+        activityMap.put(DayOfWeek.TUESDAY, "Basketball");
+        assertThat(values)
+          .containsExactly("Soccer", "Basketball", "Hiking", "Karate");
+
+        values.remove("Hiking");
+        assertThat(activityMap.containsKey(DayOfWeek.WEDNESDAY)).isFalse();
+        assertThat(activityMap.size()).isEqualTo(3);
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/hashmapvshashtable/HashmapVsHashtableDifferenceUnitTest.java

@@ -0,0 +1,98 @@
+package com.baeldung.hashmapvshashtable;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Collections;
+import java.util.ConcurrentModificationException;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+
+public class HashmapVsHashtableDifferenceUnitTest {
+
+    // null values
+    @Test(expected = NullPointerException.class)
+    public void givenHashtable_whenAddNullKey_thenNullPointerExceptionThrown() {
+        Hashtable<String, String> table = new Hashtable<String, String>();        
+        table.put(null, "value");
+    }
+    
+    @Test(expected = NullPointerException.class)
+    public void givenHashtable_whenAddNullValue_thenNullPointerExceptionThrown() {
+        Hashtable<String, String> table = new Hashtable<String, String>();        
+        table.put("key", null);
+    }
+    
+    @Test
+    public void givenHashmap_whenAddNullKeyAndValue_thenObjectAdded() {
+        HashMap<String, String> map = new HashMap<String, String>();
+        map.put(null, "value");
+        map.put("key1", null);
+        map.put("key2", null);
+        
+        assertEquals(3, map.size());
+    }
+    
+    // fail-fast iterator
+    @Test(expected = ConcurrentModificationException.class)
+    public void givenHashmap_whenModifyUnderlyingCollection_thenConcurrentModificationExceptionThrown() {
+        HashMap<String, String> map = new HashMap<String, String>();
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        map.put("key3", "value3");
+        
+        Iterator<String> iterator = map.keySet().iterator();
+        while(iterator.hasNext()){ 
+            iterator.next();
+            map.put("key4", "value4");
+        }        
+    }
+
+    @Test
+    public void givenHashtable_whenModifyUnderlyingCollection_thenItHasNoEffectOnIteratedCollection() {
+        Hashtable<String, String> table = new Hashtable<String, String>();        
+        table.put("key1", "value1");
+        table.put("key2", "value2");
+        
+        List<String> keysSelected = Lists.newArrayList(); 
+        Enumeration<String> keys = table.keys();
+        while (keys.hasMoreElements()) {
+            String key = keys.nextElement();
+            keysSelected.add(key);
+            
+            if (key.equals("key1")) {
+                table.put("key3", "value3");
+            }
+        }
+        
+        assertEquals(2, keysSelected.size());
+    }
+    
+    // synchronized map
+    @Test
+    public void givenHashmap_thenCreateSynchronizedMap() {
+        HashMap<String, String> map = new HashMap<String, String>();
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        map.put("key3", "value3");
+        
+        Set<Entry<String, String>> set = map.entrySet();
+        synchronized (map) {
+            Iterator<Entry<String, String>> it = set.iterator();
+            while(it.hasNext()) {
+                Map.Entry<String, String> elem = (Map.Entry<String, String>)it.next();
+             }            
+        }
+        
+        Map<String, String> syncMap = Collections.synchronizedMap(map);
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/hashtable/HashtableUnitTest.java

@@ -0,0 +1,274 @@
+package com.baeldung.hashtable;
+
+import java.util.ConcurrentModificationException;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.Matchers.*;
+import org.junit.Test;
+
+public class HashtableUnitTest {
+
+    @Test
+    public void whenPutAndGet_thenReturnsValue() {
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+
+        Word word = new Word("cat");
+        table.put(word, "an animal");
+
+        String definition = table.get(word);
+
+        assertEquals("an animal", definition);
+
+        definition = table.remove(word);
+
+        assertEquals("an animal", definition);
+    }
+
+    @Test
+    public void whenThesameInstanceOfKey_thenReturnsValue() {
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        Word word = new Word("cat");
+        table.put(word, "an animal");
+        String extracted = table.get(word);
+        assertEquals("an animal", extracted);
+    }
+
+    @Test
+    public void whenEqualsOverridden_thenReturnsValue() {
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        Word word = new Word("cat");
+        table.put(word, "an animal");
+        String extracted = table.get(new Word("cat"));
+        assertEquals("an animal", extracted);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void whenNullKey_thenException() {
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(null, "an animal");
+    }
+
+    @Test(expected = ConcurrentModificationException.class)
+    public void whenIterate_thenFailFast() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "an animal");
+        table.put(new Word("dog"), "another animal");
+
+        Iterator<Word> it = table.keySet().iterator();
+        System.out.println("iterator created");
+
+        table.remove(new Word("dog"));
+        System.out.println("element removed");
+
+        while (it.hasNext()) {
+            Word key = it.next();
+            System.out.println(table.get(key));
+        }
+    }
+
+    @Test
+    public void whenEnumerate_thenNotFailFast() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("1"), "one");
+        table.put(new Word("2"), "two");
+        table.put(new Word("3"), "three");
+        table.put(new Word("4"), "four");
+        table.put(new Word("5"), "five");
+        table.put(new Word("6"), "six");
+        table.put(new Word("7"), "seven");
+        table.put(new Word("8"), "eight");
+
+        Enumeration<Word> enumKey = table.keys();
+        System.out.println("Enumeration created");
+        table.remove(new Word("1"));
+        System.out.println("element removed");
+        while (enumKey.hasMoreElements()) {
+            Word key = enumKey.nextElement();
+            System.out.println(table.get(key));
+        }
+    }
+
+    @Test
+    public void whenAddElements_thenIterationOrderUnpredicable() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("1"), "one");
+        table.put(new Word("2"), "two");
+        table.put(new Word("3"), "three");
+        table.put(new Word("4"), "four");
+        table.put(new Word("5"), "five");
+        table.put(new Word("6"), "six");
+        table.put(new Word("7"), "seven");
+        table.put(new Word("8"), "eight");
+
+        Iterator<Map.Entry<Word, String>> it = table.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<Word, String> entry = it.next();
+            System.out.println(entry.getValue());
+        }
+    }
+
+    @Test
+    public void whenGetOrDefault_thenDefaultGot() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "a small domesticated carnivorous mammal");
+        Word key = new Word("dog");
+        String definition;
+
+        // old way
+        /* if (table.containsKey(key)) {
+            definition = table.get(key);
+        } else {
+            definition = "not found";
+        }*/
+
+        // new way
+        definition = table.getOrDefault(key, "not found");
+
+        assertThat(definition, is("not found"));
+    }
+
+    @Test
+    public void whenPutifAbsent_thenNotRewritten() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "a small domesticated carnivorous mammal");
+
+        String definition = "an animal";
+        // old way
+        /* if (!table.containsKey(new Word("cat"))) {
+            table.put(new Word("cat"), definition);
+        }*/
+        // new way
+        table.putIfAbsent(new Word("cat"), definition);
+
+        assertThat(table.get(new Word("cat")), is("a small domesticated carnivorous mammal"));
+    }
+
+    @Test
+    public void whenRemovePair_thenCheckKeyAndValue() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "a small domesticated carnivorous mammal");
+
+        // old way
+        /* if (table.get(new Word("cat")).equals("an animal")) {
+            table.remove(new Word("cat"));
+        }*/
+
+        // new way
+        boolean result = table.remove(new Word("cat"), "an animal");
+
+        assertThat(result, is(false));
+    }
+
+    @Test
+    public void whenReplacePair_thenValueChecked() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "a small domesticated carnivorous mammal");
+
+        String definition = "an animal";
+
+        // old way
+        /* if (table.containsKey(new Word("cat")) && table.get(new Word("cat")).equals("a small domesticated carnivorous mammal")) {
+            table.put(new Word("cat"), definition);
+        }*/
+        // new way
+        table.replace(new Word("cat"), "a small domesticated carnivorous mammal", definition);
+
+        assertThat(table.get(new Word("cat")), is("an animal"));
+
+    }
+
+    @Test
+    public void whenKeyIsAbsent_thenNotRewritten() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "a small domesticated carnivorous mammal");
+
+        // old way
+        /* if (!table.containsKey(cat)) {
+            String definition = "an animal";// calculate
+            table.put(new Word("cat"), definition);
+        }
+        */
+        // new way
+
+        table.computeIfAbsent(new Word("cat"), key -> "an animal");
+        assertThat(table.get(new Word("cat")), is("a small domesticated carnivorous mammal"));
+
+    }
+
+    @Test
+    public void whenKeyIsPresent_thenComputeIfPresent() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "a small domesticated carnivorous mammal");
+
+        Word cat = new Word("cat");
+        // old way
+        /* if (table.containsKey(cat)) {
+            String concatination = cat.getName() + " - " + table.get(cat);
+            table.put(cat, concatination);
+        }*/
+
+        // new way
+        table.computeIfPresent(cat, (key, value) -> key.getName() + " - " + value);
+
+        assertThat(table.get(cat), is("cat - a small domesticated carnivorous mammal"));
+
+    }
+
+    @Test
+    public void whenCompute_thenForAllKeys() {
+
+        Hashtable<String, Integer> table = new Hashtable<String, Integer>();
+        String[] animals = { "cat", "dog", "dog", "cat", "bird", "mouse", "mouse" };
+        for (String animal : animals) {
+            table.compute(animal, (key, value) -> (value == null ? 1 : value + 1));
+        }
+        assertThat(table.values(), hasItems(2, 2, 2, 1));
+
+    }
+
+    @Test
+    public void whenInsteadOfCompute_thenMerge() {
+
+        Hashtable<String, Integer> table = new Hashtable<String, Integer>();
+        String[] animals = { "cat", "dog", "dog", "cat", "bird", "mouse", "mouse" };
+        for (String animal : animals) {
+            table.merge(animal, 1, (oldValue, value) -> (oldValue + value));
+        }
+        assertThat(table.values(), hasItems(2, 2, 2, 1));
+    }
+
+    @Test
+    public void whenForeach_thenIterate() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "a small domesticated carnivorous mammal");
+        table.put(new Word("dog"), "another animal");
+        table.forEach((k, v) -> System.out.println(k.getName() + " - " + v)
+
+        );
+    }
+
+    @Test
+    public void whenReplaceall_thenNoIterationNeeded() {
+
+        Hashtable<Word, String> table = new Hashtable<Word, String>();
+        table.put(new Word("cat"), "a small domesticated carnivorous mammal");
+        table.put(new Word("dog"), "another animal");
+        table.replaceAll((k, v) -> k.getName() + " - " + v);
+
+        assertThat(table.values(), hasItems("cat - a small domesticated carnivorous mammal", "dog - another animal"));
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/iterators/IteratorsUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.iterators;
+
+import static com.baeldung.iterators.Iterators.failFast1;
+import static com.baeldung.iterators.Iterators.failFast2;
+import static com.baeldung.iterators.Iterators.failSafe1;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.ConcurrentModificationException;
+
+import org.junit.Test;
+
+/**
+ * Source code https://github.com/eugenp/tutorials
+ *
+ * @author Santosh Thakur
+ */
+
+public class IteratorsUnitTest {
+
+    @Test
+    public void whenFailFast_ThenThrowsException() {
+        assertThatThrownBy(() -> {
+            failFast1();
+        }).isInstanceOf(ConcurrentModificationException.class);
+    }
+
+    @Test
+    public void whenFailFast_ThenThrowsExceptionInSecondIteration() {
+        assertThatThrownBy(() -> {
+            failFast2();
+        }).isInstanceOf(ConcurrentModificationException.class);
+    }
+
+    @Test
+    public void whenFailSafe_ThenDoesNotThrowException() {
+        assertThat(failSafe1()).isGreaterThanOrEqualTo(0);
+    }
+
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/java/collections/ConcurrentModificationExceptionUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.java.collections;
+
+import org.junit.Test;
+
+import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+
+public class ConcurrentModificationExceptionUnitTest {
+
+    @Test
+    public void changingContentWithSetDoesNotThrowConcurrentModificationException() throws Exception {
+        ArrayList<Object> array = new ArrayList<>(asList(0, "one", 2, "three"));
+
+        for (Object item : array) {
+            array.set(3, 3);
+        }
+    }
+
+    @Test
+    public void removingElementUsingIteratorAPI() throws Exception {
+        List<String> originalList = new ArrayList<>(asList("zero", "one", "two", "three"));
+
+        Iterator<String> iterator = originalList.iterator();
+
+        while (iterator.hasNext()) {
+            String next = iterator.next();
+            if (Objects.equals(next, "one")) iterator.remove();
+        }
+
+        assertEquals(originalList, asList("zero", "two", "three"));
+    }
+
+    @Test
+    public void modifyingContentAndIteratingUsingListIteratorAPI() throws Exception {
+        List<String> originalList = new ArrayList<>(asList("zero", "one", "two", "three"));
+
+        ListIterator<String> iterator = originalList.listIterator();
+
+        while (iterator.hasNext()) {
+            String next = iterator.next();
+            if (Objects.equals(next, "one")) {
+                iterator.set("another");
+            }
+
+            if (Objects.equals(next, "two")) {
+                iterator.remove();
+            }
+
+            if (Objects.equals(next, "three")) {
+                iterator.add("four");
+            }
+        }
+
+        assertEquals(originalList, asList("zero", "another", "three", "four"));
+    }
+
+    @Test
+    public void removingElementUsingCopyAndListAPI() throws Exception {
+        List<String> originalList = new ArrayList<>(asList("zero", "one", "two", "three"));
+
+        List<String> listCopy = new ArrayList<>(originalList);
+
+        for (String next : listCopy) {
+            if (Objects.equals(next, "one")) originalList.remove(originalList.indexOf(next) - 1);
+        }
+
+        assertEquals(originalList, asList("one", "two", "three"));
+    }
+
+    @Test
+    public void copyOnWriteList() throws Exception {
+        List<String> originalList = new CopyOnWriteArrayList<>(asList("zero", "one", "two", "three"));
+
+        for (String next : originalList) {
+            if (Objects.equals(next, "one")) originalList.remove(originalList.indexOf(next) - 1);
+        }
+
+        assertEquals(originalList, asList("one", "two", "three"));
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/java/filtering/CollectionFiltersUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.java.filtering;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.jupiter.api.Test;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+@RunWith(JUnitPlatform.class)
+public class CollectionFiltersUnitTest {
+
+    private static final Collection<Integer> BASE_INTEGER_COLLECTION = Arrays.asList(9, 14, 2, 7, 1, 5, 8);
+    private static final Collection<Integer> EXPECTED_EVEN_FILTERED_COLLECTION = Arrays.asList(14, 2, 8);
+
+    @Test
+    public void givenAStringCollection_whenFilteringFourLetterWords_thenObtainTheFilteredCollection() {
+        final Collection<String> baseStrings = Arrays.asList("java", "baeldung", "type", "example", "other");
+
+        Collection<String> filtered = StreamsCollectionFilter.filterCollectionHelperMethod(baseStrings, item -> item.length() == 4);
+
+        assertThat(filtered).containsExactlyInAnyOrder("java", "type");
+    }
+
+    @Test
+    public void givenAnIntegerCollection_whenFilteringEvenValues_thenObtainTheFilteredCollectionForAllCases() {
+        Collection<Integer> filteredWithStreams1 = StreamsCollectionFilter.findEvenNumbers(BASE_INTEGER_COLLECTION);
+        Collection<Integer> filteredWithCollectionUtils = CollectionUtilsCollectionFilter.findEvenNumbers(new ArrayList<>(BASE_INTEGER_COLLECTION));
+        Collection<Integer> filteredWithEclipseCollections = EclipseCollectionsCollectionFilter.findEvenNumbers(BASE_INTEGER_COLLECTION);
+        Collection<Integer> filteredWithEclipseCollectionsUsingIterate = EclipseCollectionsCollectionFilter.findEvenNumbersUsingIterate(BASE_INTEGER_COLLECTION);
+        Collection<Integer> filteredWithGuava = GuavaCollectionFilter.findEvenNumbers(BASE_INTEGER_COLLECTION);
+
+        assertThat(filteredWithStreams1).hasSameElementsAs(filteredWithCollectionUtils)
+            .hasSameElementsAs(filteredWithEclipseCollections)
+            .hasSameElementsAs(filteredWithEclipseCollectionsUsingIterate)
+            .hasSameElementsAs(filteredWithEclipseCollectionsUsingIterate)
+            .hasSameElementsAs(filteredWithGuava)
+            .hasSameElementsAs(EXPECTED_EVEN_FILTERED_COLLECTION);
+    }
+
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/java/iterable/IterableSizeUnitTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.java.iterable;
+
+import static org.junit.Assert.assertEquals;
+
+import java.sql.SQLException;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import com.google.common.collect.Lists;
+
+class IterableSizeUnitTest {
+
+    private final List<String> list = Lists.newArrayList("Apple", "Orange", "Banana");
+
+    private Iterable data;
+
+    @Test
+    void whenUsingJava7_iterableOfCollectionType_thenCorrectSize() {
+
+        final int size = IterableSize.sizeUsingJava7(list);
+
+        assertEquals(3, size);
+    }
+
+    @Test
+    void whenUsingJava7_iterableNotOfCollectionType_thenCorrect() {
+
+        final SQLException exception = new SQLException();
+        exception.setNextException(new SQLException());
+        final int size = IterableSize.sizeUsingJava7(exception);
+
+        assertEquals(2, size);
+    }
+
+    @Test
+    void whenUsingJava8_thenCorrect() {
+
+        final long size = IterableSize.sizeUsingJava8(list);
+
+        assertEquals(3, size);
+    }
+
+    @Test
+    void whenUsingApacheCollections_thenCorrect() {
+
+        final int size = IterableSize.sizeUsingApacheCollections(list);
+
+        assertEquals(3, size);
+    }
+
+    @Test
+    void whenUsingGoogleGuava_thenCorrect() {
+
+        final int size = IterableSize.sizeUsingGoogleGuava(list);
+
+        assertEquals(3, size);
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingCommonsEmptyIfNullUnitTest.java

@@ -0,0 +1,37 @@
+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-modules/core-java-collections/src/test/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingJava8OptionalContainerUnitTest.java

@@ -0,0 +1,37 @@
+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 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-modules/core-java-collections/src/test/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingNullDereferenceCheckUnitTest.java

@@ -0,0 +1,38 @@
+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 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-modules/core-java-collections/src/test/java/com/baeldung/queueInterface/CustomBaeldungQueueUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.queueInterface;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class CustomBaeldungQueueUnitTest {
+
+  private CustomBaeldungQueue<Integer> customQueue;
+
+  @Before
+  public void setUp() throws Exception {
+    customQueue = new CustomBaeldungQueue<>();
+  }
+
+  @Test
+  public void givenQueueWithTwoElements_whenElementsRetrieved_checkRetrievalCorrect() {
+
+    customQueue.add(7);
+    customQueue.add(5);
+
+    int first = customQueue.poll();
+    int second = customQueue.poll();
+
+    assertEquals(7, first);
+    assertEquals(5, second);
+
+  }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/queueInterface/PriorityQueueUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.queueInterface;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.PriorityQueue;
+
+import static org.junit.Assert.assertEquals;
+
+public class PriorityQueueUnitTest {
+
+
+
+  @Test
+  public void givenIntegerQueue_whenIntegersOutOfOrder_checkRetrievalOrderIsNatural() {
+
+    PriorityQueue<Integer> integerQueue = new PriorityQueue<>();
+
+    integerQueue.add(9);
+    integerQueue.add(2);
+    integerQueue.add(4);
+
+    int first = integerQueue.poll();
+    int second = integerQueue.poll();
+    int third = integerQueue.poll();
+
+    assertEquals(2, first);
+    assertEquals(4, second);
+    assertEquals(9, third);
+
+
+  }
+
+  @Test
+  public void givenStringQueue_whenStringsAddedOutOfNaturalOrder_checkRetrievalOrderNatural() {
+
+    PriorityQueue<String> stringQueue = new PriorityQueue<>();
+
+    stringQueue.add("banana");
+    stringQueue.add("apple");
+    stringQueue.add("cherry");
+
+    String first = stringQueue.poll();
+    String second = stringQueue.poll();
+    String third = stringQueue.poll();
+
+    assertEquals("apple", first);
+    assertEquals("banana", second);
+    assertEquals("cherry", third);
+
+
+  }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/removal/RemovalUnitTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.removal;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+public class RemovalUnitTest {
+
+    Collection<String> names;
+    Collection<String> expected;
+    Collection<String> removed;
+
+    @Before
+    public void setupTestData() {
+        names = new ArrayList<>();
+        expected = new ArrayList<>();
+        removed = new ArrayList<>();
+
+        names.add("John");
+        names.add("Ana");
+        names.add("Mary");
+        names.add("Anthony");
+        names.add("Mark");
+
+        expected.add("John");
+        expected.add("Mary");
+        expected.add("Mark");
+
+        removed.add("Ana");
+        removed.add("Anthony");
+    }
+
+    @Test
+    public void givenCollectionOfNames_whenUsingIteratorToRemoveAllNamesStartingWithLetterA_finalListShouldContainNoNamesStartingWithLetterA() {
+        Iterator<String> i = names.iterator();
+
+        while (i.hasNext()) {
+            String e = i.next();
+            if (e.startsWith("A")) {
+                i.remove();
+            }
+        }
+
+        assertThat(names, is(expected));
+    }
+
+    @Test
+    public void givenCollectionOfNames_whenUsingRemoveIfToRemoveAllNamesStartingWithLetterA_finalListShouldContainNoNamesStartingWithLetterA() {
+        names.removeIf(e -> e.startsWith("A"));
+        assertThat(names, is(expected));
+    }
+
+    @Test
+    public void givenCollectionOfNames_whenUsingStreamToFilterAllNamesStartingWithLetterA_finalListShouldContainNoNamesStartingWithLetterA() {
+        Collection<String> filteredCollection = names
+                .stream()
+                .filter(e -> !e.startsWith("A"))
+                .collect(Collectors.toList());
+        assertThat(filteredCollection, is(expected));
+    }
+
+    @Test
+    public void givenCollectionOfNames_whenUsingStreamAndPartitioningByToFindNamesThatStartWithLetterA_shouldFind3MatchingAnd2NonMatching() {
+        Map<Boolean, List<String>> classifiedElements = names
+                .stream()
+                .collect(Collectors.partitioningBy((String e) -> !e.startsWith("A")));
+
+        assertThat(classifiedElements.get(Boolean.TRUE), is(expected));
+        assertThat(classifiedElements.get(Boolean.FALSE), is(removed));
+    }
+
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/shufflingcollections/ShufflingCollectionsUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.shufflingcollections;
+
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ShufflingCollectionsUnitTest {
+
+    @Test
+    public void whenShufflingList_thenListIsShuffled() {
+        List<String> students = Arrays.asList("Foo", "Bar", "Baz", "Qux");
+
+        System.out.println("List before shuffling:");
+        System.out.println(students);
+
+        Collections.shuffle(students);
+        System.out.println("List after shuffling:");
+        System.out.println(students);
+    }
+
+    @Test
+    public void whenShufflingMapEntries_thenValuesAreShuffled() {
+        Map<Integer, String> studentsById = new HashMap<>();
+        studentsById.put(1, "Foo");
+        studentsById.put(2, "Bar");
+        studentsById.put(3, "Baz");
+        studentsById.put(4, "Qux");
+
+        System.out.println("Students before shuffling:");
+        System.out.println(studentsById.values());
+
+        List<Map.Entry<Integer, String>> shuffledStudentEntries = new ArrayList<>(studentsById.entrySet());
+        Collections.shuffle(shuffledStudentEntries);
+
+        List<String> shuffledStudents = shuffledStudentEntries.stream()
+                .map(Map.Entry::getValue)
+                .collect(Collectors.toList());
+
+        System.out.println("Students after shuffling");
+        System.out.println(shuffledStudents);
+    }
+
+    @Test
+    public void whenShufflingSet_thenElementsAreShuffled() {
+        Set<String> students = new HashSet<>(Arrays.asList("Foo", "Bar", "Baz", "Qux"));
+
+        System.out.println("Set before shuffling:");
+        System.out.println(students);
+
+        List<String> studentList = new ArrayList<>(students);
+
+        Collections.shuffle(studentList);
+        System.out.println("Shuffled set elements:");
+        System.out.println(studentList);
+    }
+
+    @Test
+    public void whenShufflingWithSameRandomness_thenElementsAreShuffledDeterministically() {
+        List<String> students_1 = Arrays.asList("Foo", "Bar", "Baz", "Qux");
+        List<String> students_2 = Arrays.asList("Foo", "Bar", "Baz", "Qux");
+
+        Collections.shuffle(students_1, new Random(5));
+        Collections.shuffle(students_2, new Random(5));
+
+        assertThat(students_1).isEqualTo(students_2);
+    }
+}

core-java-modules/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-modules/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-modules/core-java-collections/src/test/java/com/baeldung/synchronizedcollections/test/SynchronizedCollectionUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.synchronizedcollections.test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class SynchronizedCollectionUnitTest {
+
+    @Test
+    public void givenSynchronizedCollection_whenTwoThreadsAddElements_thenCorrectCollectionSize() throws InterruptedException {
+        Collection<Integer> syncCollection = Collections.synchronizedCollection(new ArrayList<>());
+
+        Runnable listOperations = () -> {
+            syncCollection.addAll(Arrays.asList(1, 2, 3, 4, 5, 6));
+        };
+        Thread thread1 = new Thread(listOperations);
+        Thread thread2 = new Thread(listOperations);
+        thread1.start();
+        thread2.start();
+        thread1.join();
+        thread2.join();
+
+        assertThat(syncCollection.size()).isEqualTo(12);
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/synchronizedcollections/test/SynchronizedListUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.synchronizedcollections.test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.*;
+
+public class SynchronizedListUnitTest {
+
+    @Test
+    public void givenSynchronizedList_whenTwoThreadsAddElements_thenCorrectListSize() throws InterruptedException {
+        List<Integer> syncList = Collections.synchronizedList(new ArrayList<>());
+
+        Runnable listOperations = () -> {
+            syncList.addAll(Arrays.asList(1, 2, 3, 4, 5, 6));
+        };
+        Thread thread1 = new Thread(listOperations);
+        Thread thread2 = new Thread(listOperations);
+        thread1.start();
+        thread2.start();
+        thread1.join();
+        thread2.join();
+        
+        assertThat(syncList.size()).isEqualTo(12);
+    }
+    
+    @Test
+    public void givenStringList_whenTwoThreadsIterateOnSynchronizedList_thenCorrectResult() throws InterruptedException {
+        List<String> syncCollection = Collections.synchronizedList(Arrays.asList("a", "b", "c"));
+        List<String> uppercasedCollection = new ArrayList<>();
+
+        Runnable listOperations = () -> {
+            synchronized (syncCollection) {
+                syncCollection.forEach((e) -> {
+                    uppercasedCollection.add(e.toUpperCase());
+                });
+            }
+        };
+        
+        Thread thread1 = new Thread(listOperations);
+        Thread thread2 = new Thread(listOperations);
+        thread1.start();
+        thread2.start();
+        thread1.join();
+        thread2.join();
+        
+        assertThat(uppercasedCollection.get(0)).isEqualTo("A");
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/synchronizedcollections/test/SynchronizedMapUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.synchronizedcollections.test;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.*;
+
+public class SynchronizedMapUnitTest {
+
+    @Test
+    public void givenSynchronizedMap_whenTwoThreadsAddElements_thenCorrectMapSize() throws InterruptedException {
+        Map<Integer, String> syncMap = Collections.synchronizedMap(new HashMap<>());
+
+        Runnable mapOperations = () -> {
+            syncMap.put(1, "one");
+            syncMap.put(2, "two");
+            syncMap.put(3, "three");
+            
+        };
+        Thread thread1 = new Thread(mapOperations);
+        Thread thread2 = new Thread(mapOperations);
+        thread1.start();
+        thread2.start();
+        thread1.join();
+        thread2.join();
+        
+        assertThat(syncMap.size()).isEqualTo(3);
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/synchronizedcollections/test/SynchronizedSetUnitTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.synchronizedcollections.test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.*;
+
+public class SynchronizedSetUnitTest {
+    
+    @Test
+    public void givenSynchronizedSet_whenTwoThreadsAddElements_thenCorrectSetSize() throws InterruptedException {
+        Set<Integer> syncSet = Collections.synchronizedSet(new HashSet<>());
+        
+        Runnable setOperations = () -> {syncSet.addAll(Arrays.asList(1, 2, 3, 4, 5, 6));};
+        Thread thread1 = new Thread(setOperations);
+        Thread thread2 = new Thread(setOperations);
+        thread1.start();
+        thread2.start();
+        thread1.join();
+        thread2.join();
+        
+        assertThat(syncSet.size()).isEqualTo(6);
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/synchronizedcollections/test/SynchronizedSortedMapUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.synchronizedcollections.test;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.TreeMap;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class SynchronizedSortedMapUnitTest {
+    
+    @Test
+    public void givenSynchronizedSorteMap_whenTwoThreadsAddElements_thenCorrectSortedMapSize() throws InterruptedException {
+        Map<Integer, String> syncSortedMap = Collections.synchronizedSortedMap(new TreeMap<>());
+        
+        Runnable sortedMapOperations = () -> {
+            syncSortedMap.put(1, "One");
+            syncSortedMap.put(2, "Two");
+            syncSortedMap.put(3, "Three");
+        };
+        Thread thread1 = new Thread(sortedMapOperations);
+        Thread thread2 = new Thread(sortedMapOperations);
+        thread1.start();
+        thread2.start();
+        thread1.join();
+        thread2.join();
+        
+        assertThat(syncSortedMap.size()).isEqualTo(3);
+    }
+}

core-java-modules/core-java-collections/src/test/java/com/baeldung/synchronizedcollections/test/SynchronizedSortedSetUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.synchronizedcollections.test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class SynchronizedSortedSetUnitTest {
+    
+    @Test
+    public void givenSynchronizedSortedSet_whenTwoThreadsAddElements_thenCorrectSortedSetSize() throws InterruptedException {
+        SortedSet<Integer> syncSortedSet = Collections.synchronizedSortedSet(new TreeSet<>());
+        
+        Runnable sortedSetOperations = () -> {syncSortedSet.addAll(Arrays.asList(1, 2, 3, 4, 5, 6));};
+        sortedSetOperations.run();
+        sortedSetOperations.run();
+        Thread thread1 = new Thread(sortedSetOperations);
+        Thread thread2 = new Thread(sortedSetOperations);
+        thread1.start();
+        thread2.start();
+        thread1.join();
+        thread2.join();
+        
+        assertThat(syncSortedSet.size()).isEqualTo(6);
+    }
+}

core-java-modules/core-java-collections/src/test/java/org/baeldung/java/collections/CollectionsConcatenateUnitTest.java

@@ -0,0 +1,135 @@
+package org.baeldung.java.collections;
+
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.IterableUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static java.util.Arrays.asList;
+
+public class CollectionsConcatenateUnitTest {
+
+    @Test
+    public void givenUsingJava8_whenConcatenatingUsingConcat_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+        Collection<String> collectionC = asList("W", "X");
+
+        Stream<String> combinedStream = Stream.concat(Stream.concat(collectionA.stream(), collectionB.stream()), collectionC.stream());
+        Collection<String> collectionCombined = combinedStream.collect(Collectors.toList());
+
+        Assert.assertEquals(asList("S", "T", "U", "V", "W", "X"), collectionCombined);
+    }
+
+    @Test
+    public void givenUsingJava8_whenConcatenatingUsingflatMap_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+
+        Stream<String> combinedStream = Stream.of(collectionA, collectionB).flatMap(Collection::stream);
+        Collection<String> collectionCombined = combinedStream.collect(Collectors.toList());
+
+        Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
+    }
+
+    @Test
+    public void givenUsingGuava_whenConcatenatingUsingIterables_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+
+        Iterable<String> combinedIterables = Iterables.unmodifiableIterable(Iterables.concat(collectionA, collectionB));
+        Collection<String> collectionCombined = Lists.newArrayList(combinedIterables);
+
+        Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
+    }
+
+    @Test
+    public void givenUsingJava7_whenConcatenatingUsingIterables_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+
+        Iterable<String> combinedIterables = concat(collectionA, collectionB);
+        Collection<String> collectionCombined = makeListFromIterable(combinedIterables);
+        Assert.assertEquals(Arrays.asList("S", "T", "U", "V"), collectionCombined);
+    }
+
+    public static <E> Iterable<E> concat(Iterable<? extends E> i1, Iterable<? extends E> i2) {
+        return new Iterable<E>() {
+            public Iterator<E> iterator() {
+                return new Iterator<E>() {
+                    Iterator<? extends E> listIterator = i1.iterator();
+                    Boolean checkedHasNext;
+                    E nextValue;
+                    private boolean startTheSecond;
+
+                    void theNext() {
+                        if (listIterator.hasNext()) {
+                            checkedHasNext = true;
+                            nextValue = listIterator.next();
+                        } else if (startTheSecond)
+                            checkedHasNext = false;
+                        else {
+                            startTheSecond = true;
+                            listIterator = i2.iterator();
+                            theNext();
+                        }
+                    }
+
+                    public boolean hasNext() {
+                        if (checkedHasNext == null)
+                            theNext();
+                        return checkedHasNext;
+                    }
+
+                    public E next() {
+                        if (!hasNext())
+                            throw new NoSuchElementException();
+                        checkedHasNext = null;
+                        return nextValue;
+                    }
+
+                    public void remove() {
+                        listIterator.remove();
+                    }
+                };
+            }
+        };
+    }
+
+    public static <E> List<E> makeListFromIterable(Iterable<E> iter) {
+        List<E> list = new ArrayList<>();
+        for (E item : iter) {
+            list.add(item);
+        }
+        return list;
+    }
+
+    @Test
+    public void givenUsingApacheCommons_whenConcatenatingUsingUnion_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+
+        Iterable<String> combinedIterables = CollectionUtils.union(collectionA, collectionB);
+        Collection<String> collectionCombined = Lists.newArrayList(combinedIterables);
+
+        Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
+    }
+
+    @Test
+    public void givenUsingApacheCommons_whenConcatenatingUsingChainedIterable_thenCorrect() {
+        Collection<String> collectionA = asList("S", "T");
+        Collection<String> collectionB = asList("U", "V");
+
+        Iterable<String> combinedIterables = IterableUtils.chainedIterable(collectionA, collectionB);
+        Collection<String> collectionCombined = Lists.newArrayList(combinedIterables);
+
+        Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
+    }
+}

core-java-modules/core-java-collections/src/test/java/org/baeldung/java/collections/CollectionsJoinAndSplitJUnitTest.java

@@ -0,0 +1,62 @@
+package org.baeldung.java.collections;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class CollectionsJoinAndSplitJUnitTest {
+
+    private ArrayList<String> sauces = new ArrayList<>();
+    private ArrayList<String> cheeses = new ArrayList<>();
+    private ArrayList<String> vegetables = new ArrayList<>();
+
+    private ArrayList<ArrayList<String>> ingredients = new ArrayList<>();
+
+    @Before
+    public void init() {
+        sauces.add("Olive Oil");
+        sauces.add("Marinara");
+
+        cheeses.add("Mozzarella");
+        cheeses.add("Feta");
+        cheeses.add("Parmesan");
+
+        vegetables.add("Olives");
+        vegetables.add("Spinach");
+        vegetables.add("Green Peppers");
+
+        ingredients.add(sauces);
+        ingredients.add(cheeses);
+        ingredients.add(vegetables);
+    }
+
+    @Test
+    public void givenThreeArrayLists_whenJoiningIntoOneArrayList_shouldSucceed() {
+        ArrayList<ArrayList<String>> toppings = new ArrayList<>();
+
+        toppings.add(sauces);
+        toppings.add(cheeses);
+        toppings.add(vegetables);
+
+        Assert.assertTrue(toppings.size() == 3);
+        Assert.assertTrue(toppings.contains(sauces));
+        Assert.assertTrue(toppings.contains(cheeses));
+        Assert.assertTrue(toppings.contains(vegetables));
+    }
+
+    @Test
+    public void givenOneArrayList_whenSplittingIntoTwoArrayLists_shouldSucceed() {
+
+        ArrayList<ArrayList<String>> removedToppings = new ArrayList<>();
+        removedToppings.add(ingredients.remove(ingredients.indexOf(vegetables)));
+
+        Assert.assertTrue(removedToppings.contains(vegetables));
+        Assert.assertTrue(removedToppings.size() == 1);
+        Assert.assertTrue(ingredients.size() == 2);
+        Assert.assertTrue(ingredients.contains(sauces));
+        Assert.assertTrue(ingredients.contains(cheeses));
+    }
+}

core-java-modules/core-java-collections/src/test/java/org/baeldung/java/collections/JoinSplitCollectionsUnitTest.java

@@ -0,0 +1,154 @@
+package org.baeldung.java.collections;
+
+import org.junit.Test;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.*;
+
+public class JoinSplitCollectionsUnitTest {
+
+    @Test
+    public void whenJoiningTwoArrays_thenJoined() {
+        String[] animals1 = new String[] { "Dog", "Cat" };
+        String[] animals2 = new String[] { "Bird", "Cow" };
+        String[] result = Stream.concat(Arrays.stream(animals1), Arrays.stream(animals2)).toArray(String[]::new);
+
+        assertArrayEquals(result, new String[] { "Dog", "Cat", "Bird", "Cow" });
+    }
+
+    @Test
+    public void whenJoiningTwoCollections_thenJoined() {
+        Collection<String> collection1 = Arrays.asList("Dog", "Cat");
+        Collection<String> collection2 = Arrays.asList("Bird", "Cow", "Moose");
+        Collection<String> result = Stream.concat(collection1.stream(), collection2.stream()).collect(Collectors.toList());
+
+        assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow", "Moose")));
+    }
+
+    @Test
+    public void whenJoiningTwoCollectionsWithFilter_thenJoined() {
+        Collection<String> collection1 = Arrays.asList("Dog", "Cat");
+        Collection<String> collection2 = Arrays.asList("Bird", "Cow", "Moose");
+        Collection<String> result = Stream.concat(collection1.stream(), collection2.stream()).filter(e -> e.length() == 3).collect(Collectors.toList());
+
+        assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Cow")));
+    }
+
+    @Test
+    public void whenConvertArrayToString_thenConverted() {
+        String[] animals = new String[] { "Dog", "Cat", "Bird", "Cow" };
+        String result = Arrays.stream(animals).collect(Collectors.joining(", "));
+
+        assertEquals(result, "Dog, Cat, Bird, Cow");
+    }
+
+    @Test
+    public void whenConvertCollectionToString_thenConverted() {
+        Collection<String> animals = Arrays.asList("Dog", "Cat", "Bird", "Cow");
+        String result = animals.stream().collect(Collectors.joining(", "));
+
+        assertEquals(result, "Dog, Cat, Bird, Cow");
+    }
+
+    @Test
+    public void whenConvertMapToString_thenConverted() {
+        Map<Integer, String> animals = new HashMap<>();
+        animals.put(1, "Dog");
+        animals.put(2, "Cat");
+        animals.put(3, "Cow");
+
+        String result = animals.entrySet().stream().map(entry -> entry.getKey() + " = " + entry.getValue()).collect(Collectors.joining(", "));
+
+        assertEquals(result, "1 = Dog, 2 = Cat, 3 = Cow");
+    }
+
+    @Test
+    public void whenConvertNestedCollectionToString_thenConverted() {
+        Collection<List<String>> nested = new ArrayList<>();
+        nested.add(Arrays.asList("Dog", "Cat"));
+        nested.add(Arrays.asList("Cow", "Pig"));
+
+        String result = nested.stream().map(nextList -> nextList.stream().collect(Collectors.joining("-"))).collect(Collectors.joining("; "));
+
+        assertEquals(result, "Dog-Cat; Cow-Pig");
+    }
+
+    @Test
+    public void whenConvertCollectionToStringAndSkipNull_thenConverted() {
+        Collection<String> animals = Arrays.asList("Dog", "Cat", null, "Moose");
+        String result = animals.stream().filter(Objects::nonNull).collect(Collectors.joining(", "));
+
+        assertEquals(result, "Dog, Cat, Moose");
+    }
+
+    @Test
+    public void whenSplitCollectionHalf_thenConverted() {
+        Collection<String> animals = Arrays.asList("Dog", "Cat", "Cow", "Bird", "Moose", "Pig");
+        Collection<String> result1 = new ArrayList<>();
+        Collection<String> result2 = new ArrayList<>();
+        AtomicInteger count = new AtomicInteger();
+        int midpoint = Math.round(animals.size() / 2);
+
+        animals.forEach(next -> {
+            int index = count.getAndIncrement();
+            if (index < midpoint) {
+                result1.add(next);
+            } else {
+                result2.add(next);
+            }
+        });
+
+        assertTrue(result1.equals(Arrays.asList("Dog", "Cat", "Cow")));
+        assertTrue(result2.equals(Arrays.asList("Bird", "Moose", "Pig")));
+    }
+
+    @Test
+    public void whenSplitArrayByWordLength_thenConverted() {
+        String[] animals = new String[] { "Dog", "Cat", "Bird", "Cow", "Pig", "Moose" };
+        Map<Integer, List<String>> result = Arrays.stream(animals).collect(Collectors.groupingBy(String::length));
+
+        assertTrue(result.get(3).equals(Arrays.asList("Dog", "Cat", "Cow", "Pig")));
+        assertTrue(result.get(4).equals(Arrays.asList("Bird")));
+        assertTrue(result.get(5).equals(Arrays.asList("Moose")));
+    }
+
+    @Test
+    public void whenConvertStringToArray_thenConverted() {
+        String animals = "Dog, Cat, Bird, Cow";
+        String[] result = animals.split(", ");
+
+        assertArrayEquals(result, new String[] { "Dog", "Cat", "Bird", "Cow" });
+    }
+
+    @Test
+    public void whenConvertStringToCollection_thenConverted() {
+        String animals = "Dog, Cat, Bird, Cow";
+        Collection<String> result = Arrays.asList(animals.split(", "));
+
+        assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow")));
+    }
+
+    @Test
+    public void whenConvertStringToMap_thenConverted() {
+        String animals = "1 = Dog, 2 = Cat, 3 = Bird";
+
+        Map<Integer, String> result = Arrays.stream(animals.split(", ")).map(next -> next.split(" = ")).collect(Collectors.toMap(entry -> Integer.parseInt(entry[0]), entry -> entry[1]));
+
+        assertEquals(result.get(1), "Dog");
+        assertEquals(result.get(2), "Cat");
+        assertEquals(result.get(3), "Bird");
+    }
+
+    @Test
+    public void whenConvertCollectionToStringMultipleSeparators_thenConverted() {
+        String animals = "Dog. , Cat, Bird. Cow";
+
+        Collection<String> result = Arrays.stream(animals.split("[,|.]")).map(String::trim).filter(next -> !next.isEmpty()).collect(Collectors.toList());
+
+        assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow")));
+    }
+}

core-java-modules/core-java-collections/src/test/java/org/baeldung/java/collections/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+- [Join and Split Arrays and Collections in Java](http://www.baeldung.com/java-join-and-split)
+- [Introduction to Java Servlets](http://www.baeldung.com/intro-to-servlets)

core-java-modules/core-java-collections/src/test/java/org/baeldung/java/sorting/Employee.java

@@ -0,0 +1,62 @@
+package org.baeldung.java.sorting;
+
+public class Employee implements Comparable {
+
+    private String name;
+    private int age;
+    private double salary;
+
+    public Employee(String name, int age, double salary) {
+        this.name = name;
+        this.age = age;
+        this.salary = salary;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(double salary) {
+        this.salary = salary;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return ((Employee) obj).getName()
+            .equals(getName());
+    }
+
+    @Override
+    public int compareTo(Object o) {
+        Employee e = (Employee) o;
+        return getName().compareTo(e.getName());
+    }
+
+    @Override
+    public String toString() {
+        return new StringBuffer().append("(")
+            .append(getName())
+            .append(getAge())
+            .append(",")
+            .append(getSalary())
+            .append(")")
+            .toString();
+    }
+
+}

core-java-modules/core-java-collections/src/test/java/org/baeldung/java/sorting/JavaSortingUnitTest.java

@@ -0,0 +1,147 @@
+package org.baeldung.java.sorting;
+
+import com.google.common.primitives.Ints;
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.Map.Entry;
+
+import static org.junit.Assert.assertTrue;
+
+public class JavaSortingUnitTest {
+
+    private int[] toSort;
+    private int[] sortedInts;
+    private int[] sortedRangeInts;
+    private Employee[] employees;
+    private Employee[] employeesSorted;
+    private Employee[] employeesSortedByAge;
+    private HashMap<Integer, String> map;
+
+    @Before
+    public void initVariables() {
+
+        toSort = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
+        sortedInts = new int[] { 1, 5, 7, 66, 88, 89, 123, 200, 255 };
+        sortedRangeInts = new int[] { 5, 1, 89, 7, 88, 200, 255, 123, 66 };
+
+        employees = new Employee[] { new Employee("John", 23, 5000), new Employee("Steve", 26, 6000), new Employee("Frank", 33, 7000), new Employee("Earl", 43, 10000), new Employee("Jessica", 23, 4000), new Employee("Pearl", 33, 6000) };
+        employeesSorted = new Employee[] { new Employee("Earl", 43, 10000), new Employee("Frank", 33, 70000), new Employee("Jessica", 23, 4000), new Employee("John", 23, 5000), new Employee("Pearl", 33, 4000), new Employee("Steve", 26, 6000) };
+        employeesSortedByAge = new Employee[] { new Employee("John", 23, 5000), new Employee("Jessica", 23, 4000), new Employee("Steve", 26, 6000), new Employee("Frank", 33, 70000), new Employee("Pearl", 33, 4000), new Employee("Earl", 43, 10000) };
+
+        map = new HashMap<>();
+        map.put(55, "John");
+        map.put(22, "Apple");
+        map.put(66, "Earl");
+        map.put(77, "Pearl");
+        map.put(12, "George");
+        map.put(6, "Rocky");
+
+    }
+
+    @Test
+    public void givenIntArray_whenUsingSort_thenSortedArray() {
+        Arrays.sort(toSort);
+
+        assertTrue(Arrays.equals(toSort, sortedInts));
+    }
+
+    @Test
+    public void givenIntegerArray_whenUsingSort_thenSortedArray() {
+        Integer[] integers = ArrayUtils.toObject(toSort);
+        Arrays.sort(integers, Comparator.comparingInt(a -> a));
+
+        assertTrue(Arrays.equals(integers, ArrayUtils.toObject(sortedInts)));
+    }
+
+    @Test
+    public void givenArray_whenUsingSortWithLambdas_thenSortedArray() {
+        Integer[] integersToSort = ArrayUtils.toObject(toSort);
+        Arrays.sort(integersToSort, Comparator.comparingInt(a -> a));
+
+        assertTrue(Arrays.equals(integersToSort, ArrayUtils.toObject(sortedInts)));
+    }
+
+    @Test
+    public void givenEmpArray_SortEmpArray_thenSortedArrayinNaturalOrder() {
+        Arrays.sort(employees);
+
+        assertTrue(Arrays.equals(employees, employeesSorted));
+    }
+
+    @Test
+    public void givenIntArray_whenUsingRangeSort_thenRangeSortedArray() {
+        Arrays.sort(toSort, 3, 7);
+
+        assertTrue(Arrays.equals(toSort, sortedRangeInts));
+    }
+
+    @Test
+    public void givenIntArray_whenUsingParallelSort_thenArraySorted() {
+        Arrays.parallelSort(toSort);
+
+        assertTrue(Arrays.equals(toSort, sortedInts));
+    }
+
+    @Test
+    public void givenArrayObjects_whenUsingComparing_thenSortedArrayObjects() {
+        List<Employee> employeesList = Arrays.asList(employees);
+
+        employeesList.sort(Comparator.comparing(Employee::getAge));// .thenComparing(Employee::getName));
+
+        assertTrue(Arrays.equals(employeesList.toArray(), employeesSortedByAge));
+    }
+
+    @Test
+    public void givenList_whenUsingSort_thenSortedList() {
+        List<Integer> toSortList = Ints.asList(toSort);
+        Collections.sort(toSortList);
+
+        assertTrue(Arrays.equals(toSortList.toArray(), ArrayUtils.toObject(sortedInts)));
+    }
+
+    @Test
+    public void givenMap_whenSortingByKeys_thenSortedMap() {
+        Integer[] sortedKeys = new Integer[] { 6, 12, 22, 55, 66, 77 };
+
+        List<Map.Entry<Integer, String>> entries = new ArrayList<>(map.entrySet());
+        entries.sort(Comparator.comparing(Entry::getKey));
+        HashMap<Integer, String> sortedMap = new LinkedHashMap<>();
+        for (Map.Entry<Integer, String> entry : entries) {
+            sortedMap.put(entry.getKey(), entry.getValue());
+        }
+
+        assertTrue(Arrays.equals(sortedMap.keySet()
+            .toArray(), sortedKeys));
+    }
+
+    @Test
+    public void givenMap_whenSortingByValues_thenSortedMap() {
+        String[] sortedValues = new String[] { "Apple", "Earl", "George", "John", "Pearl", "Rocky" };
+
+        List<Map.Entry<Integer, String>> entries = new ArrayList<>(map.entrySet());
+        entries.sort(Comparator.comparing(Entry::getValue));
+        HashMap<Integer, String> sortedMap = new LinkedHashMap<>();
+        for (Map.Entry<Integer, String> entry : entries) {
+            sortedMap.put(entry.getKey(), entry.getValue());
+        }
+
+        assertTrue(Arrays.equals(sortedMap.values()
+            .toArray(), sortedValues));
+    }
+
+    @Test
+    public void givenSet_whenUsingSort_thenSortedSet() {
+        HashSet<Integer> integersSet = new LinkedHashSet<>(Ints.asList(toSort));
+        HashSet<Integer> descSortedIntegersSet = new LinkedHashSet<>(Arrays.asList(255, 200, 123, 89, 88, 66, 7, 5, 1));
+
+        ArrayList<Integer> list = new ArrayList<>(integersSet);
+        list.sort((i1, i2) -> i2 - i1);
+        integersSet = new LinkedHashSet<>(list);
+
+        assertTrue(Arrays.equals(integersSet.toArray(), descSortedIntegersSet.toArray()));
+    }
+
+}