Merge remote-tracking branch 'Baeldung/master' into active_mq

# Conflicts:
#	.gitignore
#	LICENSE
#	README.md
#	core-java-modules/README.md
#	core-java-modules/core-java-11/README.md
#	core-java-modules/core-java-11/pom.xml
#	core-java-modules/core-java-8/README.md
#	core-java-modules/core-java-8/pom.xml
#	core-java-modules/core-java-8/src/main/resources/logback.xml
#	core-java-modules/core-java-annotations/README.md
#	core-java-modules/core-java-annotations/pom.xml
#	core-java-modules/core-java-collections-2/README.md
#	core-java-modules/core-java-collections-2/pom.xml
#	core-java-modules/core-java-collections-3/README.md
#	core-java-modules/core-java-collections-3/pom.xml
#	core-java-modules/core-java-collections-conversions-2/README.md
#	core-java-modules/core-java-collections-conversions-2/pom.xml
#	core-java-modules/core-java-collections-conversions/README.md
#	core-java-modules/core-java-collections-conversions/pom.xml
#	core-java-modules/core-java-collections-list/README.md
#	core-java-modules/core-java-collections-list/pom.xml
#	core-java-modules/core-java-collections/pom.xml
#	core-java-modules/core-java-datetime-conversion/README.md
#	core-java-modules/core-java-datetime-conversion/pom.xml
#	core-java-modules/core-java-datetime-conversion/src/test/java/com/baeldung/datetime/ConvertInstantToTimestampUnitTest.java
#	core-java-modules/core-java-io-2/pom.xml
#	core-java-modules/core-java-io/README.md
#	core-java-modules/core-java-io/pom.xml
#	core-java-modules/core-java-io/src/test/resources/fileTest.txt
#	core-java-modules/core-java-io/src/test/resources/sampleTextFile.txt
#	core-java-modules/core-java-lambdas/README.md
#	core-java-modules/core-java-lambdas/pom.xml
#	core-java-modules/core-java-serialization/pom.xml
#	core-java-modules/core-java-streams/README.md
#	core-java-modules/core-java-streams/pom.xml
#	core-java-modules/core-java-strings/README.md
#	core-java-modules/core-java-strings/pom.xml
#	core-java-modules/core-java-strings/src/test/resources/stringtoolong.txt
#	core-java-modules/core-java-uuid/README.md
#	core-java-modules/core-java-uuid/pom.xml
#	core-java-modules/pom.xml
#	image-processing/README.md
#	image-processing/pom.xml
#	image-processing/src/main/java/com/baeldung/imageprocessing/addingtext/AddText.java
#	image-processing/src/main/java/com/baeldung/imageprocessing/opencv/CameraStream.java
#	jackson-modules/jackson-annotations/README.md
#	jackson-modules/jackson-annotations/pom.xml
#	jackson-modules/jackson-conversions-2/README.md
#	jackson-modules/jackson-conversions-2/pom.xml
#	jackson-modules/jackson-conversions/README.md
#	jackson-modules/jackson-conversions/pom.xml
#	jackson-modules/jackson-custom-conversions/README.md
#	jackson-modules/jackson-custom-conversions/pom.xml
#	jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/defaultserializercustomserializer/CallingDefaultSerializerUnitTest.java
#	jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/deserialization/CustomDeserializationUnitTest.java
#	jackson-modules/jackson-exceptions/README.md
#	jackson-modules/jackson-exceptions/pom.xml
#	jackson-modules/jackson-exceptions/src/test/java/com/baeldung/exceptions/JacksonExceptionsUnitTest.java
#	jackson-modules/jackson-exceptions/src/test/java/com/baeldung/mappingexception/JacksonMappingExceptionUnitTest.java
#	jackson-modules/pom.xml
#	parent-boot-1/pom.xml
#	parent-boot-2/pom.xml
#	parent-boot-3/pom.xml
#	patterns-modules/design-patterns-architectural/pom.xml
#	patterns-modules/design-patterns-architectural/src/main/java/com/baeldung/repositoryvsdaopattern/UserDaoImpl.java
#	patterns-modules/design-patterns-behavioral-2/README.md
#	patterns-modules/design-patterns-behavioral-2/pom.xml
#	patterns-modules/design-patterns-creational-2/README.md
#	patterns-modules/design-patterns-creational-2/pom.xml
#	patterns-modules/design-patterns-singleton/README.md
#	patterns-modules/design-patterns-structural/src/main/resources/log4jstructuraldp.properties
#	patterns-modules/enterprise-patterns/pom.xml
#	patterns-modules/intercepting-filter/pom.xml
#	patterns-modules/pom.xml
#	persistence-modules/activejdbc/pom.xml
#	persistence-modules/hibernate5/README.md
#	persistence-modules/hibernate5/pom.xml
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/CustomInterceptor.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/entity/User.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/namingstrategy/CustomPhysicalNamingStrategy.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/Customer.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/HashMapConverter.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryIdClass.java
#	persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryPK.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/IdentifiersIntegrationTest.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/bootstrap/BootstrapAPIIntegrationTest.java
#	persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/proxy/HibernateProxyUnitTest.java
#	persistence-modules/hibernate5/src/test/resources/hibernate-interceptors.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-lifecycle.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-namingstrategy.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate-persistjson.properties
#	persistence-modules/hibernate5/src/test/resources/hibernate.properties
#	persistence-modules/pom.xml
#	persistence-modules/spring-data-jpa-crud/pom.xml
#	persistence-modules/spring-data-jpa-crud/src/main/java/com/baeldung/repository/FruitRepository.java
#	persistence-modules/spring-data-jpa-repo-2/README.md
#	persistence-modules/spring-data-jpa-repo-2/pom.xml
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/model/User.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/repository/CustomUserRepositoryImpl.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/saveperformance/Book.java
#	persistence-modules/spring-data-jpa-repo-2/src/main/resources/application.properties
#	persistence-modules/spring-data-mongodb-reactive/pom.xml
#	persistence-modules/spring-data-redis/README.md
#	persistence-modules/spring-data-redis/pom.xml
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/reactive/redis/config/RedisConfig.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/config/RedisConfig.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/model/Student.java
#	persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/queue/RedisMessageSubscriber.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisKeyCommandsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateListOpsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateValueOpsManualTest.java
#	persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/redis/repo/StudentRepositoryManualTest.java
#	pom.xml
#	testing-modules/assertion-libraries/README.md
#	testing-modules/assertion-libraries/pom.xml
#	testing-modules/junit-5-basics/README.md
#	testing-modules/junit-5-basics/pom.xml
#	testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Helper.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Main.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Helper.java
#	testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Main.java
#	testing-modules/mockito-2/src/test/java/com/baeldung/nullmatcher/MainUnitTest.java
#	testing-modules/mockito-2/src/test/java/com/baeldung/wantedbutnotinvocked/MainUnitTest.java
#	testing-modules/pom.xml
#	testing-modules/spring-mockito/pom.xml
#	web-modules/dropwizard/pom.xml
#	web-modules/jakarta-ee/README.md
#	web-modules/jakarta-ee/pom.xml
#	web-modules/jakarta-ee/src/test/java/com/baeldung/eclipse/krazo/UserControllerUnitTest.java
#	web-modules/java-lite/pom.xml
#	web-modules/javax-servlets-2/README.md
#	web-modules/javax-servlets-2/pom.xml
#	web-modules/javax-servlets/pom.xml
#	web-modules/jee-7/pom.xml
#	web-modules/jooby/pom.xml
#	web-modules/ninja/pom.xml
#	web-modules/pom.xml
#	web-modules/ratpack/pom.xml
#	web-modules/resteasy/pom.xml
#	web-modules/restx/pom.xml
#	web-modules/spark-java/pom.xml
#	web-modules/vraptor/pom.xml
#	xml/README.md
#	xml/pom.xml
#	xml/src/main/resources/customer-binding.xml
#	xml/src/main/resources/sax/baeldung.xml
#	xml/src/test/resources/example_default_parser.xml
#	xml/src/test/resources/example_dom4j.xml
#	xml/src/test/resources/example_jaxb.xml
#	xml/src/test/resources/example_jaxen.xml
#	xml/src/test/resources/example_jdom.xml
#	xml/src/test/resources/example_stax.xml
#	xml/src/test/resources/sax/baeldung.xml
#	xml/src/test/resources/xml/websites.xml
#	xml/src/test/resources/xml/xee_attribute.xml

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

@@ -0,0 +1,39 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/combiningcollections/CombiningLists.java

@@ -0,0 +1,46 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/combiningcollections/CombiningMaps.java

@@ -0,0 +1,47 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/combiningcollections/CombiningSets.java

@@ -0,0 +1,42 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/filtering/CollectionUtilsCollectionFilter.java

@@ -0,0 +1,16 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/filtering/EclipseCollectionsCollectionFilter.java

@@ -0,0 +1,32 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/filtering/GuavaCollectionFilter.java

@@ -0,0 +1,17 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/filtering/StreamsCollectionFilter.java

@@ -0,0 +1,26 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/iterable/CustomIterableClient.java

@@ -0,0 +1,17 @@
+package com.baeldung.collections.iterable;
+
+class CustomIterableClient {
+
+    public static void main(String[] args) {
+
+        ShoppingCart<Product> shoppingCart = new ShoppingCart<>();
+        shoppingCart.add(new Product("Tuna", 42));
+        shoppingCart.add(new Product("Eggplant", 65));
+        shoppingCart.add(new Product("Salad", 45));
+        shoppingCart.add(new Product("Banana", 29));
+
+        for (Product product : shoppingCart) {
+            System.out.println(product.getName());
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.baeldung.collections.iterable;
+
+import java.util.Iterator;
+import java.util.List;
+
+public class IterableExample {
+
+    public void iterateUsingIterator(List<Integer> numbers) {
+        Iterator<Integer> iterator = numbers.iterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+    }
+
+    public void iterateUsingEnhancedForLoop(List<Integer> numbers) {
+        for (Integer number : numbers) {
+            System.out.println(number);
+        }
+    }
+
+    public void iterateUsingForEachLoop(List<Integer> numbers) {
+        numbers.forEach(System.out::println);
+    }
+
+    public void removeElementsUsingIterator(List<Integer> numbers) {
+        Iterator<Integer> iterator = numbers.iterator();
+        while (iterator.hasNext()) {
+            iterator.next();
+            iterator.remove();
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+package com.baeldung.collections.iterable;
+
+class Product {
+
+    private String name;
+    private double price;
+
+    public Product(String code, double price) {
+        this.name = code;
+        this.price = price;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+
+    public void setPrice(double price) {
+        this.price = price;
+    }
+}

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

@@ -0,0 +1,72 @@
+package com.baeldung.collections.iterable;
+
+import java.util.Arrays;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class ShoppingCart<E> implements Iterable<E> {
+
+    private E[] elementData;
+    private int size;
+
+    public ShoppingCart() {
+        this.elementData = (E[]) new Object[]{};
+    }
+
+    public void add(E element) {
+        ensureCapacity(size + 1);
+        elementData[size++] = element;
+    }
+
+    private void ensureCapacity(int minCapacity) {
+        int oldCapacity = elementData.length;
+        int newCapacity = oldCapacity + (oldCapacity >> 1);
+        if (newCapacity - minCapacity < 0) {
+            newCapacity = minCapacity;
+        }
+        elementData = Arrays.copyOf(elementData, newCapacity);
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return new ShoppingCartIterator();
+    }
+
+    public class ShoppingCartIterator implements Iterator<E> {
+        int cursor;
+        int lastReturned = -1;
+
+        public boolean hasNext() {
+            return cursor != size;
+        }
+
+        public E next() {
+            return getNextElement();
+        }
+
+        private E getNextElement() {
+            int current = cursor;
+            exist(current);
+
+            E[] elements = ShoppingCart.this.elementData;
+            validate(elements, current);
+
+            cursor = current + 1;
+            lastReturned = current;
+            return elements[lastReturned];
+        }
+
+        private void exist(int current) {
+            if (current >= size) {
+                throw new NoSuchElementException();
+            }
+        }
+
+        private void validate(E[] elements, int current) {
+            if (current >= elements.length) {
+                throw new ConcurrentModificationException();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+package com.baeldung.collections.iterablesize;
+
+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-2/src/main/java/com/baeldung/collections/iterator/CustomIteratorClient.java

@@ -0,0 +1,14 @@
+package com.baeldung.collections.iterator;
+
+import java.util.Iterator;
+
+class CustomIteratorClient {
+
+    public static void main(String[] args) {
+        Iterator<Integer> iterator = Numbers.iterator();
+
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+    }
+}

core-java-modules/core-java-collections-2/src/main/java/com/baeldung/collections/iterator/Numbers.java

@@ -0,0 +1,60 @@
+package com.baeldung.collections.iterator;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+class Numbers {
+
+    private static final List<Integer> NUMBER_LIST = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+
+    private Numbers() {
+    }
+
+    public static Iterator<Integer> iterator() {
+        return new PrimeIterator();
+    }
+
+    private static class PrimeIterator implements Iterator<Integer> {
+
+        private int cursor;
+
+        @Override
+        public Integer next() {
+            exist(cursor);
+            return NUMBER_LIST.get(cursor++);
+        }
+
+        private void exist(int current) {
+            if (current >= NUMBER_LIST.size()) {
+                throw new NoSuchElementException();
+            }
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (cursor > NUMBER_LIST.size()) {
+                return false;
+            }
+
+            for (int i = cursor; i < NUMBER_LIST.size(); i++) {
+                if (isPrime(NUMBER_LIST.get(i))) {
+                    cursor = i;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private boolean isPrime(int number) {
+            for (int i = 2; i <= number / 2; ++i) {
+                if (number % i == 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}

core-java-modules/core-java-collections-2/src/main/java/com/baeldung/collections/nullsafecollectionstreams/NullSafeCollectionStreamsUsingCommonsEmptyIfNull.java

@@ -0,0 +1,19 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/nullsafecollectionstreams/NullSafeCollectionStreamsUsingJava8OptionalContainer.java

@@ -0,0 +1,21 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/nullsafecollectionstreams/NullSafeCollectionStreamsUsingNullDereferenceCheck.java

@@ -0,0 +1,19 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/removal/CollectionRemoveIf.java

@@ -0,0 +1,19 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/removal/Iterators.java

@@ -0,0 +1,28 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/removal/StreamFilterAndCollector.java

@@ -0,0 +1,23 @@
+package com.baeldung.collections.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-2/src/main/java/com/baeldung/collections/removal/StreamPartitioningBy.java

@@ -0,0 +1,28 @@
+package com.baeldung.collections.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-2/src/test/java/com/baeldung/collections/combiningcollections/CombiningArraysUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.collections.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-2/src/test/java/com/baeldung/collections/combiningcollections/CombiningListsUnitTest.java

@@ -0,0 +1,57 @@
+package com.baeldung.collections.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-2/src/test/java/com/baeldung/collections/combiningcollections/CombiningMapsUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.collections.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-2/src/test/java/com/baeldung/collections/combiningcollections/CombiningSetsUnitTest.java

@@ -0,0 +1,45 @@
+
+package com.baeldung.collections.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-2/src/test/java/com/baeldung/collections/filtering/CollectionFiltersUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.collections.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-2/src/test/java/com/baeldung/collections/iterable/IterableUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.collections.iterable;
+
+import com.baeldung.collections.iterable.IterableExample;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class IterableUnitTest {
+
+    private static List<Integer> getNumbers() {
+        List<Integer> numbers = new ArrayList<>();
+        numbers.add(10);
+        numbers.add(20);
+        numbers.add(30);
+        numbers.add(40);
+        return numbers;
+    }
+
+    @Test
+    void givenNumbers_whenUsingIterator_thenCorrectSize() {
+        List<Integer> numbers = getNumbers();
+        IterableExample iterableExample = new IterableExample();
+        iterableExample.iterateUsingIterator(numbers);
+        assertEquals(4, numbers.size());
+    }
+
+    @Test
+    void givenNumbers_whenRemoveElements_thenEmptyList() {
+        List<Integer> numbers = getNumbers();
+        IterableExample iterableExample = new IterableExample();
+        iterableExample.removeElementsUsingIterator(numbers);
+        assertEquals(0, numbers.size());
+    }
+
+    @Test
+    void givenNumbers_whenIterateUsingEnhancedForLoop_thenCorrectSize() {
+        List<Integer> numbers = getNumbers();
+        IterableExample iterableExample = new IterableExample();
+        iterableExample.iterateUsingEnhancedForLoop(numbers);
+        assertEquals(4, numbers.size());
+    }
+
+    @Test
+    void givenNumbers_whenIterateUsingForEachLoop_thenCorrectSize() {
+        List<Integer> numbers = getNumbers();
+        IterableExample iterableExample = new IterableExample();
+        iterableExample.iterateUsingForEachLoop(numbers);
+        assertEquals(4, numbers.size());
+    }
+}

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

@@ -0,0 +1,59 @@
+package com.baeldung.collections.iterablesize;
+
+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-2/src/test/java/com/baeldung/collections/joinsplit/CollectionsJoinAndSplitJUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.collections.joinsplit;
+
+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));
+    }
+}