[BAEL-10836] - Moved Java8CollectionCleanupUnitTest, AddElementsUnitTest and articles

2018-12-29 20:11:40 +05:30
parent bb435c3cbf
commit cf3d7b69e6
5 changed files with 1 additions and 1 deletions
@@ -17,7 +17,6 @@
 - [Finding Max/Min of a List or Collection](http://www.baeldung.com/java-collection-min-max)
 - [Collections.emptyList() vs. New List Instance](https://www.baeldung.com/java-collections-emptylist-new-list)
 - [Remove All Occurrences of a Specific Value from a List](https://www.baeldung.com/java-remove-value-from-list)
- [Converting a Collection to ArrayList in Java](https://www.baeldung.com/java-convert-collection-arraylist)
 - [Check If Two Lists are Equal in Java](http://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)
 - [Java 8 Streams: Find Items From One List Based On Values From Another List](https://www.baeldung.com/java-streams-find-list-items)
 - [A Guide to the Java LinkedList](http://www.baeldung.com/java-linkedlist)
@@ -0,0 +1,28 @@
+package com.baeldung.list;
+
+public class Flower {
+
+    private String name;
+    private int petals;
+
+    public Flower(String name, int petals) {
+        this.name = name;
+        this.petals = petals;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getPetals() {
+        return petals;
+    }
+
+    public void setPetals(int petals) {
+        this.petals = petals;
+    }
+}
@@ -0,0 +1,49 @@
+package com.baeldung.java8;
+
+import com.google.common.collect.Lists;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.hasSize;
+import static org.junit.Assert.assertThat;
+
+public class Java8CollectionCleanupUnitTest {
+
+    // tests -
+
+    @Test
+    public void givenListContainsNulls_whenFilteringParallel_thenCorrect() {
+        final List<Integer> list = Lists.newArrayList(null, 1, 2, null, 3, null);
+        final List<Integer> listWithoutNulls = list.parallelStream().filter(Objects::nonNull).collect(Collectors.toList());
+
+        assertThat(listWithoutNulls, hasSize(3));
+    }
+
+    @Test
+    public void givenListContainsNulls_whenFilteringSerial_thenCorrect() {
+        final List<Integer> list = Lists.newArrayList(null, 1, 2, null, 3, null);
+        final List<Integer> listWithoutNulls = list.stream().filter(Objects::nonNull).collect(Collectors.toList());
+
+        assertThat(listWithoutNulls, hasSize(3));
+    }
+
+    @Test
+    public void givenListContainsNulls_whenRemovingNullsWithRemoveIf_thenCorrect() {
+        final List<Integer> listWithoutNulls = Lists.newArrayList(null, 1, 2, null, 3, null);
+        listWithoutNulls.removeIf(Objects::isNull);
+
+        assertThat(listWithoutNulls, hasSize(3));
+    }
+
+    @Test
+    public void givenListContainsDuplicates_whenRemovingDuplicatesWithJava8_thenCorrect() {
+        final List<Integer> listWithDuplicates = Lists.newArrayList(1, 1, 2, 2, 3, 3);
+        final List<Integer> listWithoutDuplicates = listWithDuplicates.parallelStream().distinct().collect(Collectors.toList());
+
+        assertThat(listWithoutDuplicates, hasSize(3));
+    }
+
+}
@@ -0,0 +1,87 @@
+package com.baeldung.list;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.*;
+
+import static org.junit.Assert.*;
+
+public class AddElementsUnitTest {
+
+    List<Flower> flowers;
+
+    @Before
+    public void init() {
+        this.flowers = new ArrayList<>(Arrays.asList(
+                new Flower("Poppy", 12),
+                new Flower("Anemone", 8),
+                new Flower("Catmint", 12)));
+    }
+
+    @Test
+    public void givenAList_whenTargetListIsEmpty_thenReturnTargetListWithNewItems() {
+        List<Flower> anotherList = new ArrayList<>();
+        anotherList.addAll(flowers);
+
+        assertEquals(anotherList.size(), flowers.size());
+        Assert.assertTrue(anotherList.containsAll(flowers));
+    }
+
+    @Test
+    public void givenAList_whenTargetListIsEmpty_thenReturnTargetListWithOneModifiedElementByConstructor() {
+        List<Flower> anotherList = new ArrayList<>();
+        anotherList.addAll(flowers);
+
+        Flower flower = anotherList.get(0);
+        flower.setPetals(flowers.get(0).getPetals() * 3);
+
+        assertEquals(anotherList.size(), flowers.size());
+        Assert.assertTrue(anotherList.containsAll(flowers));
+    }
+
+    @Test
+    public void givenAListAndElements_whenUseCollectionsAddAll_thenAddElementsToTargetList() {
+        List<Flower> target = new ArrayList<>();
+
+        Collections.addAll(target, flowers.get(0), flowers.get(1), flowers.get(2), flowers.get(0));
+
+        assertEquals(target.size(), 4);
+    }
+
+    @Test
+    public void givenTwoList_whenSourceListDoesNotHaveNullElements_thenAddElementsToTargetListSkipFirstElementByStreamProcess() {
+        List<Flower> flowerVase = new ArrayList<>();
+
+        flowers.stream()
+                .skip(1)
+                .forEachOrdered(flowerVase::add);
+
+        assertEquals(flowerVase.size() + 1, flowers.size());
+        assertFalse(flowerVase.containsAll(flowers));
+    }
+
+    @Test
+    public void givenTwoList_whenSourceListDoesNotHaveNullElements_thenAddElementsToTargetListFilteringElementsByStreamProcess() {
+        List<Flower> flowerVase = new ArrayList<>();
+
+        flowers.stream()
+                .filter(f -> f.getPetals() > 10)
+                .forEachOrdered(flowerVase::add);
+
+        assertEquals(flowerVase.size() + 1, flowers.size());
+        assertFalse(flowerVase.containsAll(flowers));
+    }
+
+    @Test
+    public void givenAList_whenListIsNotNull_thenAddElementsToListByStreamProcessWihtOptional() {
+        List<Flower> target = new ArrayList<>();
+
+        Optional.ofNullable(flowers)
+                .ifPresent(target::addAll);
+
+        assertNotNull(target);
+        assertEquals(target.size(), 3);
+    }
+}