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

core-java-modules/core-java-collections/src/main/java/com/baeldung/charstack/CharStack.java

@@ -0,0 +1,37 @@
+package com.baeldung.charstack;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+public class CharStack {
+
+    private LinkedList<Character> items;
+
+    public CharStack() {
+        this.items = new LinkedList<Character>();
+    }
+
+    public void push(Character item) {
+        items.push(item);
+    }
+
+    public Character peek() {
+        return items.getFirst();
+    }
+
+    public Character pop() {
+
+        Iterator<Character> iter = items.iterator();
+        Character item = iter.next();
+        if (item != null) {
+            iter.remove();
+            return item;
+        }
+        return null;
+    }
+
+    public int size() {
+        return items.size();
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/charstack/CharStackWithArray.java

@@ -0,0 +1,48 @@
+package com.baeldung.charstack;
+
+public class CharStackWithArray {
+
+    private char[] elements;
+    private int size;
+
+    public CharStackWithArray() {
+        size = 0;
+        elements = new char[4];
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public char peek() {
+        if (size == 0) {
+            throw new EmptyStackException();
+        }
+        return elements[size - 1];
+    }
+
+    public char pop() {
+        if (size == 0) {
+            throw new EmptyStackException();
+        }
+
+        return elements[--size];
+    }
+
+    public void push(char item) {
+        ensureCapacity(size + 1);
+        elements[size] = item;
+        size++;
+    }
+
+    private void ensureCapacity(int newSize) {
+        char newBiggerArray[];
+
+        if (elements.length < newSize) {
+            newBiggerArray = new char[elements.length * 2];
+            System.arraycopy(elements, 0, newBiggerArray, 0, size);
+            elements = newBiggerArray;
+        }
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/charstack/EmptyStackException.java

@@ -0,0 +1,9 @@
+package com.baeldung.charstack;
+
+public class EmptyStackException extends RuntimeException {
+
+    public EmptyStackException() {
+        super("Stack is empty");
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/combiningcollections/CombiningArrays.java

@@ -0,0 +1,39 @@
+package com.baeldung.combiningcollections;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import com.google.common.collect.ObjectArrays;
+
+public class CombiningArrays {
+    
+    public static Object[] usingNativeJava(Object[] first, Object[] second) {
+        Object[] combined = new Object[first.length + second.length];
+        System.arraycopy(first, 0, combined, 0, first.length);
+        System.arraycopy(second, 0, combined, first.length, second.length);
+        return combined;
+    }
+    
+    public static Object[] usingJava8ObjectStream(Object[] first, Object[] second) {
+        Object[] combined = Stream.concat(Arrays.stream(first), Arrays.stream(second)).toArray();
+        return combined;
+    }
+
+    public static Object[] usingJava8FlatMaps(Object[] first, Object[] second) {
+        Object[] combined = Stream.of(first, second).flatMap(Stream::of).toArray(String[]::new);
+        return combined;
+    }
+    
+    public static Object[] usingApacheCommons(Object[] first, Object[] second) {
+        Object[] combined = ArrayUtils.addAll(first, second);
+        return combined;
+    }
+
+    public static Object[] usingGuava(Object[] first, Object[] second) {
+        Object [] combined = ObjectArrays.concat(first, second, Object.class);
+        return combined;
+    }
+    
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/combiningcollections/CombiningLists.java

@@ -0,0 +1,46 @@
+package com.baeldung.combiningcollections;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.commons.collections4.ListUtils;
+
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+
+public class CombiningLists {
+    
+    public static List<Object> usingNativeJava(List<Object> first, List<Object> second) {
+        List<Object> combined = new ArrayList<>();
+        combined.addAll(first);
+        combined.addAll(second);
+        return combined;
+    }
+    
+    public static List<Object> usingJava8ObjectStream(List<Object> first, List<Object> second) {
+        List<Object> combined = Stream.concat(first.stream(), second.stream()).collect(Collectors.toList());
+        return combined;
+    }
+
+    public static List<Object> usingJava8FlatMaps(List<Object> first, List<Object> second) {
+        List<Object> combined = Stream.of(first, second).flatMap(Collection::stream).collect(Collectors.toList());
+        return combined;
+    }
+    
+    public static List<Object> usingApacheCommons(List<Object> first, List<Object> second) {
+        List<Object> combined = ListUtils.union(first, second);
+        return combined;
+    }
+
+    public static List<Object> usingGuava(List<Object> first, List<Object> second) {
+        Iterable<Object> combinedIterables = Iterables.unmodifiableIterable(
+        Iterables.concat(first, second));
+        
+        List<Object> combined = Lists.newArrayList(combinedIterables);
+        return combined;
+    }
+    
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/combiningcollections/CombiningMaps.java

@@ -0,0 +1,47 @@
+package com.baeldung.combiningcollections;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.commons.exec.util.MapUtils;
+
+import com.google.common.collect.ImmutableMap;
+
+public class CombiningMaps {
+    
+    public static Map<String, String> usingPlainJava(Map<String, String> first, Map<String, String> second) {
+    	Map<String, String> combined = new HashMap<>();
+    	combined.putAll(first);
+    	combined.putAll(second);
+        return combined;
+    }
+    
+    public static Map<String, String> usingJava8ForEach(Map<String, String> first, Map<String, String> second) {
+    	second.forEach((key, value) -> first.merge(key, value, String::concat));
+        return first;
+    }
+
+    public static Map<String, String> usingJava8FlatMaps(Map<String, String> first, Map<String, String> second) {
+		Map<String, String> combined = Stream.of(first, second).map(Map::entrySet).flatMap(Collection::stream)
+				.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, String::concat));
+		return combined;
+
+    }
+    
+    public static Map<String, String> usingApacheCommons(Map<String, String> first, Map<String, String> second) {
+        Map<String, String> combined = MapUtils.merge(first, second);
+        return combined;
+    }
+
+    public static Map<String, String> usingGuava(Map<String, String> first, Map<String, String> second) {
+        Map<String, String> combined = ImmutableMap.<String, String>builder()
+          .putAll(first)
+          .putAll(second)
+          .build();
+        return combined;
+    }
+    
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/combiningcollections/CombiningSets.java

@@ -0,0 +1,42 @@
+package com.baeldung.combiningcollections;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.commons.collections4.SetUtils;
+
+import com.google.common.collect.Sets;
+
+public class CombiningSets {
+    
+    public static Set<Object> usingNativeJava(Set<Object> first, Set<Object> second) {
+        Set<Object> combined = new HashSet<>();
+        combined.addAll(first);
+        combined.addAll(second);
+        return combined;
+    }
+    
+    public static Set<Object> usingJava8ObjectStream(Set<Object> first, Set<Object> second) {
+        Set<Object> combined = Stream.concat(first.stream(), second.stream()).collect(Collectors.toSet());
+        return combined;
+    }
+
+    public static Set<Object> usingJava8FlatMaps(Set<Object> first, Set<Object> second) {
+        Set<Object> combined = Stream.of(first, second).flatMap(Collection::stream).collect(Collectors.toSet());
+        return combined;
+    }
+    
+    public static Set<Object> usingApacheCommons(Set<Object> first, Set<Object> second) {
+        Set<Object> combined = SetUtils.union(first, second);
+        return combined;
+    }
+
+    public static Set<Object> usingGuava(Set<Object> first, Set<Object> second) {
+        Set<Object> combined = Sets.union(first, second);
+        return combined;
+    }
+    
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/hashtable/Word.java

@@ -0,0 +1,28 @@
+package com.baeldung.hashtable;
+
+public class Word {
+    private String name;
+
+    public Word(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof Word))
+            return false;
+
+        Word word = (Word) o;
+        return word.getName().equals(this.name) ? true : false;
+
+    }
+
+    public int hashCode() {
+        return name.hashCode();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/iteratorguide/IteratorGuide.java

@@ -0,0 +1,39 @@
+package com.baeldung.iteratorguide;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class IteratorGuide {
+    
+    public static void main(String[] args) {
+        List<String> items = new ArrayList<>();
+        items.add("ONE");
+        items.add("TWO");
+        items.add("THREE");
+        Iterator<String> iter = items.iterator();
+        while (iter.hasNext()) {
+                String next = iter.next();
+                System.out.println(next);
+                iter.remove();
+        }
+        ListIterator<String> listIterator = items.listIterator();
+        while(listIterator.hasNext()) {
+            String nextWithIndex = items.get(listIterator.nextIndex());
+            String next = listIterator.next();
+            if( "ONE".equals(next)) {
+                listIterator.set("SWAPPED");
+            }
+        }
+        listIterator.add("FOUR");
+        while(listIterator.hasPrevious()) {
+            String previousWithIndex = items.get(listIterator.previousIndex());
+            String previous = listIterator.previous();
+            System.out.println(previous);
+        }
+        listIterator.forEachRemaining(e -> {
+            System.out.println(e);
+        });
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/iterators/Iterators.java

@@ -0,0 +1,80 @@
+package com.baeldung.iterators;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Source code https://github.com/eugenp/tutorials
+ *
+ * @author Santosh Thakur
+ */
+
+public class Iterators {
+
+    public static int failFast1() {
+        ArrayList<Integer> numbers = new ArrayList<>();
+
+        numbers.add(10);
+        numbers.add(20);
+        numbers.add(30);
+        numbers.add(40);
+
+        Iterator<Integer> iterator = numbers.iterator();
+        while (iterator.hasNext()) {
+            Integer number = iterator.next();
+            numbers.add(50);
+        }
+
+        return numbers.size();
+    }
+
+    public static int failFast2() {
+        ArrayList<Integer> numbers = new ArrayList<>();
+        numbers.add(10);
+        numbers.add(20);
+        numbers.add(30);
+        numbers.add(40);
+
+        Iterator<Integer> iterator = numbers.iterator();
+        while (iterator.hasNext()) {
+            if (iterator.next() == 30) {
+                // will not throw Exception
+                iterator.remove();
+            }
+        }
+
+        System.out.println("using iterator's remove method = " + numbers);
+
+        iterator = numbers.iterator();
+        while (iterator.hasNext()) {
+            if (iterator.next() == 40) {
+                // will throw Exception on
+                // next call of next() method
+                numbers.remove(2);
+            }
+        }
+
+        return numbers.size();
+    }
+
+    public static int failSafe1() {
+        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
+
+        map.put("First", 10);
+        map.put("Second", 20);
+        map.put("Third", 30);
+        map.put("Fourth", 40);
+
+        Iterator<String> iterator = map.keySet()
+            .iterator();
+
+        while (iterator.hasNext()) {
+            String key = iterator.next();
+            map.put("Fifth", 50);
+        }
+
+        return map.size();
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/java/filtering/CollectionUtilsCollectionFilter.java

@@ -0,0 +1,16 @@
+package com.baeldung.java.filtering;
+
+import java.util.Collection;
+
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.Predicate;
+
+public class CollectionUtilsCollectionFilter {
+
+    static public Collection<Integer> findEvenNumbers(Collection<Integer> baseCollection) {
+        Predicate<Integer> apacheEventNumberPredicate = item -> item % 2 == 0;
+
+        CollectionUtils.filter(baseCollection, apacheEventNumberPredicate);
+        return baseCollection;
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/java/filtering/EclipseCollectionsCollectionFilter.java

@@ -0,0 +1,32 @@
+package com.baeldung.java.filtering;
+
+import java.util.Collection;
+
+import org.eclipse.collections.api.block.predicate.Predicate;
+import org.eclipse.collections.impl.factory.Lists;
+import org.eclipse.collections.impl.utility.Iterate;
+
+public class EclipseCollectionsCollectionFilter {
+
+    static public Collection<Integer> findEvenNumbers(Collection<Integer> baseCollection) {
+        Predicate<Integer> eclipsePredicate = item -> item % 2 == 0;
+        Collection<Integer> filteredList = Lists.mutable.ofAll(baseCollection)
+            .select(eclipsePredicate);
+
+        return filteredList;
+    }
+
+    static public Collection<Integer> findEvenNumbersUsingIterate(Collection<Integer> baseCollection) {
+        Predicate<Integer> eclipsePredicate = new Predicate<Integer>() {
+            private static final long serialVersionUID = 1L;
+
+            @Override
+            public boolean accept(Integer arg0) {
+                return arg0 % 2 == 0;
+            }
+        };
+        Collection<Integer> filteredList = Iterate.select(baseCollection, eclipsePredicate);
+
+        return filteredList;
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/java/filtering/GuavaCollectionFilter.java

@@ -0,0 +1,17 @@
+package com.baeldung.java.filtering;
+
+import java.util.Collection;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
+
+public class GuavaCollectionFilter {
+
+    static public Collection<Integer> findEvenNumbers(Collection<Integer> baseCollection) {
+        Predicate<Integer> guavaPredicate = item -> item % 2 == 0;
+
+        Collection<Integer> filteredCollection = Collections2.filter(baseCollection, guavaPredicate);
+        return filteredCollection;
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/java/filtering/StreamsCollectionFilter.java

@@ -0,0 +1,26 @@
+package com.baeldung.java.filtering;
+
+import java.util.Collection;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class StreamsCollectionFilter {
+
+    public static <T> Collection<T> filterCollectionHelperMethod(Collection<T> baseCollection, Predicate<T> predicate) {
+        return baseCollection.stream()
+            .filter(predicate)
+            .collect(Collectors.toList());
+    }
+
+    static public Collection<Integer> findEvenNumbersUsingHelperMethod(Collection<Integer> baseCollection) {
+        return filterCollectionHelperMethod(baseCollection, item -> item % 2 == 0);
+    }
+
+    static public Collection<Integer> findEvenNumbers(Collection<Integer> baseCollection) {
+        Predicate<Integer> streamsPredicate = item -> item % 2 == 0;
+
+        return baseCollection.stream()
+            .filter(streamsPredicate)
+            .collect(Collectors.toList());
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/java/iterable/IterableSize.java

@@ -0,0 +1,65 @@
+package com.baeldung.java.iterable;
+
+import java.util.Collection;
+import java.util.stream.StreamSupport;
+
+import org.apache.commons.collections4.IterableUtils;
+
+import com.google.common.collect.Iterables;
+
+/**
+ * Provides methods for getting the size of an {@link Iterable} object.
+ */
+public class IterableSize {
+
+    /**
+     * Get the size of {@code Iterable} using Java 7.
+     *
+     * @param data the iterable
+     * @return the size of the iterable
+     */
+    public static int sizeUsingJava7(final Iterable data) {
+
+        if (data instanceof Collection) {
+            return ((Collection<?>) data).size();
+        }
+        int counter = 0;
+        for (final Object i : data) {
+            counter++;
+        }
+        return counter;
+    }
+
+    /**
+     * Get the size of {@code Iterable} using Java 8.
+     *
+     * @param data the iterable
+     * @return the size of the iterable
+     */
+    public static long sizeUsingJava8(final Iterable data) {
+
+        return StreamSupport.stream(data.spliterator(), false).count();
+    }
+
+    /**
+     * Get the size of {@code Iterable} using Apache Collections.
+     *
+     * @param data the iterable
+     * @return the size of the iterable
+     */
+    public static int sizeUsingApacheCollections(final Iterable data) {
+
+        return IterableUtils.size(data);
+    }
+
+    /**
+     * Get the size of {@code Iterable} using Google Guava.
+     *
+     * @param data the iterable
+     * @return the size of the iterable
+     */
+    public static int sizeUsingGoogleGuava(final Iterable data) {
+
+        return Iterables.size(data);
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/java/list/VectorExample.java

@@ -0,0 +1,27 @@
+package com.baeldung.java.list;
+
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Vector;
+
+public class VectorExample {
+
+    public static void main(String[] args) {
+
+        Vector<String> vector = new Vector<>();
+        vector.add("baeldung");
+        vector.add("Vector");
+        vector.add("example");
+
+        Enumeration e = vector.elements();
+        while(e.hasMoreElements()){
+            System.out.println(e.nextElement());
+        }
+
+        Iterator<String> iterator = vector.iterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+    }
+
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/java/sort/CollectionsSortCompare.java

@@ -0,0 +1,39 @@
+package com.baeldung.java.sort;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class CollectionsSortCompare {
+
+    public static void main(String[] args) {
+        sortPrimitives();
+        sortReferenceType();
+        sortCollection();
+    }
+
+    private static void sortReferenceType() {
+        Integer[] numbers = {5, 22, 10, 0};
+        Arrays.sort(numbers);
+        System.out.println(Arrays.toString(numbers));
+    }
+
+    private static void sortCollection() {
+        List<Integer> numbersList = new ArrayList<>();
+        numbersList.add(5);
+        numbersList.add(22);
+        numbersList.add(10);
+        numbersList.add(0);
+
+        Collections.sort(numbersList);
+
+        numbersList.forEach(System.out::print);
+    }
+
+    private static void sortPrimitives() {
+        int[] numbers = {5, 22, 10, 0};
+        Arrays.sort(numbers);
+        System.out.println(Arrays.toString(numbers));
+    }
+}

core-java-modules/core-java-collections/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-modules/core-java-collections/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-modules/core-java-collections/src/main/java/com/baeldung/nullsafecollectionstreams/NullSafeCollectionStreamsUsingNullDereferenceCheck.java

@@ -0,0 +1,19 @@
+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-modules/core-java-collections/src/main/java/com/baeldung/performance/ArrayListBenchmark.java

@@ -0,0 +1,90 @@
+package com.baeldung.performance;
+
+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 = 10)
+public class ArrayListBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        List<Employee> employeeList = new ArrayList<>();
+        Vector<Employee> employeeVector = new Vector<>();
+        //LinkedList<Employee> employeeList = new LinkedList<>();
+
+        long iterations = 100000;
+
+        Employee employee = new Employee(100L, "Harry");
+
+        int employeeIndex = -1;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeList.add(new Employee(i, "John"));
+                employeeVector.add(new Employee(i, "John"));
+            }
+
+            employeeList.add(employee);
+            employeeVector.add(employee);
+            employeeIndex = employeeList.indexOf(employee);
+        }
+    }
+
+    @Benchmark
+    public void testAddAt(ArrayListBenchmark.MyState state) {
+        state.employeeList.add((int) (state.iterations), new Employee(state.iterations, "John"));
+    }
+
+    @Benchmark
+    public boolean testContains(ArrayListBenchmark.MyState state) {
+        return state.employeeList.contains(state.employee);
+    }
+
+    @Benchmark
+    public boolean testContainsVector(ArrayListBenchmark.MyState state) {
+        return state.employeeVector.contains(state.employee);
+    }
+
+    @Benchmark
+    public int testIndexOf(ArrayListBenchmark.MyState state) {
+        return state.employeeList.indexOf(state.employee);
+    }
+
+    @Benchmark
+    public Employee testGet(ArrayListBenchmark.MyState state) {
+        return state.employeeList.get(state.employeeIndex);
+    }
+
+    @Benchmark
+    public Employee testVectorGet(ArrayListBenchmark.MyState state) {
+        return state.employeeVector.get(state.employeeIndex);
+    }
+
+    @Benchmark
+    public boolean testRemove(ArrayListBenchmark.MyState state) {
+        return state.employeeList.remove(state.employee);
+    }
+
+    @Benchmark
+    public void testAdd(ArrayListBenchmark.MyState state) {
+        state.employeeList.add(new Employee(state.iterations + 1, "John"));
+    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(ArrayListBenchmark.class.getSimpleName()).threads(3)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/ArraySortBenchmark.java

@@ -0,0 +1,51 @@
+package com.baeldung.performance;
+
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Measurement(batchSize = 100000, iterations = 10)
+@Warmup(batchSize = 100000, iterations = 10)
+public class ArraySortBenchmark {
+
+    @State(Scope.Thread)
+    public static class Initialize {
+        Integer[] numbers = { -769214442, -1283881723, 1504158300, -1260321086, -1800976432, 1278262737, 1863224321, 1895424914, 2062768552, -1051922993, 751605209, -1500919212, 2094856518, -1014488489, -931226326, -1677121986, -2080561705, 562424208, -1233745158, 41308167 };
+        int[] primitives = { -769214442, -1283881723, 1504158300, -1260321086, -1800976432, 1278262737, 1863224321, 1895424914, 2062768552, -1051922993, 751605209, -1500919212, 2094856518, -1014488489, -931226326, -1677121986, -2080561705, 562424208, -1233745158, 41308167 };
+    }
+
+    @Benchmark
+    public Integer[] benchmarkArraysIntegerSort(ArraySortBenchmark.Initialize state) {
+        Arrays.sort(state.numbers);
+        return state.numbers;
+    }
+
+    @Benchmark
+    public int[] benchmarkArraysIntSort(ArraySortBenchmark.Initialize state) {
+        Arrays.sort(state.primitives);
+        return state.primitives;
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(ArraySortBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/CollectionsBenchmark.java

@@ -0,0 +1,59 @@
+package com.baeldung.performance;
+
+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.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Warmup(iterations = 5)
+public class CollectionsBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+        private Set<Employee> employeeSet = new HashSet<>();
+        private List<Employee> employeeList = new ArrayList<>();
+
+        private long iterations = 10000;
+
+        private Employee employee = new Employee(100L, "Harry");
+
+        @Setup(Level.Trial)
+        public void setUp() {
+
+            for (long i = 0; i < iterations; i++) {
+                employeeSet.add(new Employee(i, "John"));
+                employeeList.add(new Employee(i, "John"));
+            }
+
+            employeeList.add(employee);
+            employeeSet.add(employee);
+        }
+    }
+
+    @Benchmark
+    public boolean testArrayList(MyState state) {
+        return state.employeeList.contains(state.employee);
+    }
+
+    @Benchmark
+    public boolean testHashSet(MyState state) {
+        return state.employeeSet.contains(state.employee);
+    }
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(CollectionsBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/CopyOnWriteBenchmark.java

@@ -0,0 +1,78 @@
+package com.baeldung.performance;
+
+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.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class CopyOnWriteBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        CopyOnWriteArrayList<Employee> employeeList = new CopyOnWriteArrayList<>();
+
+        long iterations = 100000;
+
+        Employee employee = new Employee(100L, "Harry");
+
+        int employeeIndex = -1;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeList.add(new Employee(i, "John"));
+            }
+
+            employeeList.add(employee);
+
+            employeeIndex = employeeList.indexOf(employee);
+        }
+    }
+
+        @Benchmark
+    public void testAdd(CopyOnWriteBenchmark.MyState state) {
+            state.employeeList.add(new Employee(state.iterations + 1, "John"));
+    }
+
+    @Benchmark
+    public void testAddAt(CopyOnWriteBenchmark.MyState state) {
+        state.employeeList.add((int) (state.iterations), new Employee(state.iterations, "John"));
+    }
+
+    @Benchmark
+    public boolean testContains(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.contains(state.employee);
+    }
+
+    @Benchmark
+    public int testIndexOf(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.indexOf(state.employee);
+    }
+
+    @Benchmark
+    public Employee testGet(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.get(state.employeeIndex);
+    }
+
+    @Benchmark
+    public boolean testRemove(CopyOnWriteBenchmark.MyState state) {
+        return state.employeeList.remove(state.employee);
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(CopyOnWriteBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/Employee.java

@@ -0,0 +1,55 @@
+package com.baeldung.performance;
+
+public class Employee {
+
+    private Long id;
+    private String name;
+
+    public Employee(Long id, String name) {
+        this.name = name;
+        this.id = id;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Employee employee = (Employee) o;
+
+        if (!id.equals(employee.id)) return false;
+        return name.equals(employee.name);
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = id.hashCode();
+        result = 31 * result + name.hashCode();
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee{" +
+                "id=" + id +
+                ", name='" + name + '\'' +
+                '}';
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/HashMapBenchmark.java

@@ -0,0 +1,73 @@
+package com.baeldung.performance;
+
+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.MICROSECONDS)
+@Warmup(iterations = 10)
+public class HashMapBenchmark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        Map<Long, Employee> employeeMap = new HashMap<>();
+        //LinkedHashMap<Long, Employee> employeeMap = new LinkedHashMap<>();
+        //IdentityHashMap<Long, Employee> employeeMap = new IdentityHashMap<>();
+        //WeakHashMap<Long, Employee> employeeMap = new WeakHashMap<>();
+        //ConcurrentHashMap<Long, Employee> employeeMap = new ConcurrentHashMap<>();
+        //ConcurrentSkipListMap<Long, Employee> employeeMap = new ConcurrentSkipListMap <>();
+
+        // TreeMap
+
+        long iterations = 100000;
+
+        Employee employee = new Employee(100L, "Harry");
+
+        int employeeIndex = -1;
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeMap.put(i, new Employee(i, "John"));
+            }
+
+            //employeeMap.put(iterations, employee);
+        }
+    }
+
+    @Benchmark
+    public Employee testGet(HashMapBenchmark.MyState state) {
+        return state.employeeMap.get(state.iterations);
+    }
+
+    @Benchmark
+    public Employee testRemove(HashMapBenchmark.MyState state) {
+        return state.employeeMap.remove(state.iterations);
+    }
+
+    @Benchmark
+    public Employee testPut(HashMapBenchmark.MyState state) {
+        return state.employeeMap.put(state.employee.getId(), state.employee);
+    }
+
+    @Benchmark
+    public Boolean testContainsKey(HashMapBenchmark.MyState state) {
+        return state.employeeMap.containsKey(state.employee.getId());
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(HashMapBenchmark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/performance/SetBenchMark.java

@@ -0,0 +1,66 @@
+package com.baeldung.performance;
+
+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.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.ConcurrentSkipListSet;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@Warmup(iterations = 10)
+public class SetBenchMark {
+
+    @State(Scope.Thread)
+    public static class MyState {
+
+        //Set<Employee> employeeSet = new HashSet<>();
+        LinkedHashSet<Employee> employeeSet = new LinkedHashSet<>();
+        //ConcurrentSkipListSet<Employee> employeeSet = new ConcurrentSkipListSet <>();
+
+        // TreeSet 
+
+        long iterations = 1000;
+        Employee employee = new Employee(100L, "Harry");
+
+        @Setup(Level.Trial)
+        public void setUp() {
+            for (long i = 0; i < iterations; i++) {
+                employeeSet.add(new Employee(i, "John"));
+            }
+
+            //employeeSet.add(employee);
+        }
+    }
+
+    @Benchmark
+    public boolean testAdd(SetBenchMark.MyState state) {
+        return state.employeeSet.add(state.employee);
+    }
+
+    @Benchmark
+    public Boolean testContains(SetBenchMark.MyState state) {
+        return state.employeeSet.contains(state.employee);
+    }
+
+    @Benchmark
+    public boolean testRemove(SetBenchMark.MyState state) {
+        return state.employeeSet.remove(state.employee);
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        Options options = new OptionsBuilder()
+                .include(SetBenchMark.class.getSimpleName()).threads(1)
+                .forks(1).shouldFailOnError(true)
+                .shouldDoGC(true)
+                .jvmArgs("-server").build();
+        new Runner(options).run();
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/queueInterface/CustomBaeldungQueue.java

@@ -0,0 +1,48 @@
+package com.baeldung.queueInterface;
+
+import java.util.AbstractQueue;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+public class CustomBaeldungQueue<T> extends AbstractQueue<T> {
+
+  private LinkedList<T> elements;
+
+  public CustomBaeldungQueue() {
+    this.elements = new LinkedList<T>();
+  }
+
+  @Override
+  public Iterator<T> iterator() {
+    return elements.iterator();
+  }
+
+  @Override
+  public int size() {
+    return elements.size();
+  }
+
+  @Override
+  public boolean offer(T t) {
+    if(t == null) return false;
+    elements.add(t);
+    return true;
+  }
+
+  @Override
+  public T poll() {
+
+    Iterator<T> iter = elements.iterator();
+    T t = iter.next();
+    if(t != null){
+      iter.remove();
+      return t;
+    }
+    return null;
+  }
+
+  @Override
+  public T peek() {
+    return elements.getFirst();
+  }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/removal/CollectionRemoveIf.java

@@ -0,0 +1,19 @@
+package com.baeldung.removal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class CollectionRemoveIf {
+
+    public static void main(String args[]) {
+        Collection<String> names = new ArrayList<>();
+        names.add("John");
+        names.add("Ana");
+        names.add("Mary");
+        names.add("Anthony");
+        names.add("Mark");
+
+        names.removeIf(e -> e.startsWith("A"));
+        System.out.println(String.join(",", names));
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/removal/Iterators.java

@@ -0,0 +1,28 @@
+package com.baeldung.removal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+public class Iterators {
+
+    public static void main(String args[]) {
+        Collection<String> names = new ArrayList<>();
+        names.add("John");
+        names.add("Ana");
+        names.add("Mary");
+        names.add("Anthony");
+        names.add("Mark");
+
+        Iterator<String> i = names.iterator();
+
+        while (i.hasNext()) {
+            String e = i.next();
+            if (e.startsWith("A")) {
+                i.remove();
+            }
+        }
+
+        System.out.println(String.join(",", names));
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/removal/StreamFilterAndCollector.java

@@ -0,0 +1,23 @@
+package com.baeldung.removal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+public class StreamFilterAndCollector {
+
+    public static void main(String args[]) {
+        Collection<String> names = new ArrayList<>();
+        names.add("John");
+        names.add("Ana");
+        names.add("Mary");
+        names.add("Anthony");
+        names.add("Mark");
+
+        Collection<String> filteredCollection = names
+                .stream()
+                .filter(e -> !e.startsWith("A"))
+                .collect(Collectors.toList());
+        System.out.println(String.join(",", filteredCollection));
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/removal/StreamPartitioningBy.java

@@ -0,0 +1,28 @@
+package com.baeldung.removal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class StreamPartitioningBy {
+
+    public static void main(String args[]) {
+        Collection<String> names = new ArrayList<>();
+        names.add("John");
+        names.add("Ana");
+        names.add("Mary");
+        names.add("Anthony");
+        names.add("Mark");
+
+        Map<Boolean, List<String>> classifiedElements = names
+                .stream()
+                .collect(Collectors.partitioningBy((String e) -> !e.startsWith("A")));
+
+        String matching = String.join(",", classifiedElements.get(Boolean.TRUE));
+        String nonMatching = String.join(",", classifiedElements.get(Boolean.FALSE));
+        System.out.println("Matching elements: " + matching);
+        System.out.println("Non matching elements: " + nonMatching);
+    }
+}

core-java-modules/core-java-collections/src/main/java/com/baeldung/synchronizedcollections/application/Application.java

@@ -0,0 +1,18 @@
+package com.baeldung.synchronizedcollections.application;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Logger;
+
+public class Application {
+
+    private static final Logger LOGGER = Logger.getLogger(Application.class.getName());
+    
+    public static void main(String[] args) throws InterruptedException {
+        List<Integer> syncCollection = Collections.synchronizedList(Arrays.asList(1, 2, 3, 4, 5, 6));
+        synchronized (syncCollection) {
+            syncCollection.forEach((e) -> {LOGGER.info(e.toString());});
+        }
+    }
+}

core-java-modules/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-modules/core-java-collections/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>