[BAEL-12897] - Moved set related articles from core-java-collections, core-java to core-java-collections-set

2019-04-28 23:25:52 +05:30
parent a6b462c7eb
commit 566ce43d90
7 changed files with 5 additions and 5 deletions
@@ -0,0 +1,45 @@
+package com.baeldung.enumset;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+
+public class EnumSets {
+
+    public enum Color {
+        RED, YELLOW, GREEN, BLUE, BLACK, WHITE
+    }
+
+    public static void main(String[] args) {
+        EnumSet<Color> allColors = EnumSet.allOf(Color.class);
+        System.out.println(allColors);
+
+        EnumSet<Color> noColors = EnumSet.noneOf(Color.class);
+        System.out.println(noColors);
+
+        EnumSet<Color> blackAndWhite = EnumSet.of(Color.BLACK, Color.WHITE);
+        System.out.println(blackAndWhite);
+
+        EnumSet<Color> noBlackOrWhite = EnumSet.complementOf(blackAndWhite);
+        System.out.println(noBlackOrWhite);
+
+        EnumSet<Color> range = EnumSet.range(Color.YELLOW, Color.BLUE);
+        System.out.println(range);
+
+        EnumSet<Color> blackAndWhiteCopy = EnumSet.copyOf(EnumSet.of(Color.BLACK, Color.WHITE));
+        System.out.println(blackAndWhiteCopy);
+
+        List<Color> colorsList = new ArrayList<>();
+        colorsList.add(Color.RED);
+        EnumSet<Color> listCopy = EnumSet.copyOf(colorsList);
+        System.out.println(listCopy);
+
+        EnumSet<Color> set = EnumSet.noneOf(Color.class);
+        set.add(Color.RED);
+        set.add(Color.YELLOW);
+        set.contains(Color.RED);
+        set.forEach(System.out::println);
+        set.remove(Color.RED);
+    }
+
+}
@@ -0,0 +1,93 @@
+package com.baeldung.collection;
+
+import java.util.ConcurrentModificationException;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class WhenUsingHashSet {
+
+    @Test
+    public void whenAddingElement_shouldAddElement() {
+        Set<String> hashset = new HashSet<>();
+        Assert.assertTrue(hashset.add("String Added"));
+    }
+
+    @Test
+    public void whenCheckingForElement_shouldSearchForElement() {
+        Set<String> hashsetContains = new HashSet<>();
+        hashsetContains.add("String Added");
+        Assert.assertTrue(hashsetContains.contains("String Added"));
+    }
+
+    @Test
+    public void whenCheckingTheSizeOfHashSet_shouldReturnThesize() {
+        Set<String> hashSetSize = new HashSet<>();
+        hashSetSize.add("String Added");
+        Assert.assertEquals(1, hashSetSize.size());
+    }
+
+    @Test
+    public void whenCheckingForEmptyHashSet_shouldCheckForEmpty() {
+        Set<String> emptyHashSet = new HashSet<>();
+        Assert.assertTrue(emptyHashSet.isEmpty());
+    }
+
+    @Test
+    public void whenRemovingElement_shouldRemoveElement() {
+        Set<String> removeFromHashSet = new HashSet<>();
+        removeFromHashSet.add("String Added");
+        Assert.assertTrue(removeFromHashSet.remove("String Added"));
+    }
+
+    @Test
+    public void whenClearingHashSet_shouldClearHashSet() {
+        Set<String> clearHashSet = new HashSet<>();
+        clearHashSet.add("String Added");
+        clearHashSet.clear();
+        Assert.assertTrue(clearHashSet.isEmpty());
+    }
+
+    @Test
+    public void whenIteratingHashSet_shouldIterateHashSet() {
+        Set<String> hashset = new HashSet<>();
+        hashset.add("First");
+        hashset.add("Second");
+        hashset.add("Third");
+        Iterator<String> itr = hashset.iterator();
+        while (itr.hasNext()) {
+            System.out.println(itr.next());
+        }
+    }
+
+    @Test(expected = ConcurrentModificationException.class)
+    public void whenModifyingHashSetWhileIterating_shouldThrowException() {
+        Set<String> hashset = new HashSet<>();
+        hashset.add("First");
+        hashset.add("Second");
+        hashset.add("Third");
+        Iterator<String> itr = hashset.iterator();
+        while (itr.hasNext()) {
+            itr.next();
+            hashset.remove("Second");
+        }
+    }
+
+    @Test
+    public void whenRemovingElementUsingIterator_shouldRemoveElement() {
+        Set<String> hashset = new HashSet<>();
+        hashset.add("First");
+        hashset.add("Second");
+        hashset.add("Third");
+        Iterator<String> itr = hashset.iterator();
+        while (itr.hasNext()) {
+            String element = itr.next();
+            if (element.equals("Second"))
+                itr.remove();
+        }
+        Assert.assertEquals(2, hashset.size());
+    }
+}
@@ -0,0 +1,228 @@
+package com.baeldung.collection;
+
+import java.util.Comparator;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.NavigableSet;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class WhenUsingTreeSet {
+
+    private static class Element {
+        private Integer id;
+
+        public Integer getId() {
+            return id;
+        }
+
+        public void setId(Integer id) {
+            this.id = id;
+        }
+
+        @Override
+        public String toString() {
+            return id.toString();
+        }
+    }
+
+    private Comparator<Element> comparator = (ele1, ele2) -> {
+        return ele1.getId()
+            .compareTo(ele2.getId());
+    };
+
+    @Test
+    public void whenAddingElement_shouldAddElement() {
+        Set<String> treeSet = new TreeSet<>();
+        Assert.assertTrue(treeSet.add("String Added"));
+    }
+
+    @Test
+    public void whenCheckingForElement_shouldSearchForElement() {
+        Set<String> treeSetContains = new TreeSet<>();
+        treeSetContains.add("String Added");
+        Assert.assertTrue(treeSetContains.contains("String Added"));
+    }
+
+    @Test
+    public void whenRemovingElement_shouldRemoveElement() {
+        Set<String> removeFromTreeSet = new TreeSet<>();
+        removeFromTreeSet.add("String Added");
+        Assert.assertTrue(removeFromTreeSet.remove("String Added"));
+    }
+
+    @Test
+    public void whenClearingTreeSet_shouldClearTreeSet() {
+        Set<String> clearTreeSet = new TreeSet<>();
+        clearTreeSet.add("String Added");
+        clearTreeSet.clear();
+        Assert.assertTrue(clearTreeSet.isEmpty());
+    }
+
+    @Test
+    public void whenCheckingTheSizeOfTreeSet_shouldReturnThesize() {
+        Set<String> treeSetSize = new TreeSet<>();
+        treeSetSize.add("String Added");
+        Assert.assertEquals(1, treeSetSize.size());
+    }
+
+    @Test
+    public void whenCheckingForEmptyTreeSet_shouldCheckForEmpty() {
+        Set<String> emptyTreeSet = new TreeSet<>();
+        Assert.assertTrue(emptyTreeSet.isEmpty());
+    }
+
+    @Test
+    public void whenIteratingTreeSet_shouldIterateTreeSetInAscendingOrder() {
+        Set<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Second");
+        treeSet.add("Third");
+        Iterator<String> itr = treeSet.iterator();
+        while (itr.hasNext()) {
+            System.out.println(itr.next());
+        }
+    }
+
+    @Test
+    public void whenIteratingTreeSet_shouldIterateTreeSetInDescendingOrder() {
+        TreeSet<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Second");
+        treeSet.add("Third");
+        Iterator<String> itr = treeSet.descendingIterator();
+        while (itr.hasNext()) {
+            System.out.println(itr.next());
+        }
+    }
+
+    @Test(expected = ConcurrentModificationException.class)
+    public void whenModifyingTreeSetWhileIterating_shouldThrowException() {
+        Set<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Second");
+        treeSet.add("Third");
+        Iterator<String> itr = treeSet.iterator();
+        while (itr.hasNext()) {
+            itr.next();
+            treeSet.remove("Second");
+        }
+    }
+
+    @Test
+    public void whenRemovingElementUsingIterator_shouldRemoveElement() {
+        Set<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Second");
+        treeSet.add("Third");
+        Iterator<String> itr = treeSet.iterator();
+        while (itr.hasNext()) {
+            String element = itr.next();
+            if (element.equals("Second"))
+                itr.remove();
+        }
+        Assert.assertEquals(2, treeSet.size());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void whenAddingNullToNonEmptyTreeSet_shouldThrowException() {
+        Set<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add(null);
+    }
+
+    @Test
+    public void whenCheckingFirstElement_shouldReturnFirstElement() {
+        TreeSet<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        Assert.assertEquals("First", treeSet.first());
+    }
+
+    @Test
+    public void whenCheckingLastElement_shouldReturnLastElement() {
+        TreeSet<String> treeSet = new TreeSet<>();
+        treeSet.add("First");
+        treeSet.add("Last");
+        Assert.assertEquals("Last", treeSet.last());
+    }
+
+    @Test
+    public void whenUsingComparator_shouldSortAndInsertElements() {
+        Set<Element> treeSet = new TreeSet<>(comparator);
+        Element ele1 = new Element();
+        ele1.setId(100);
+        Element ele2 = new Element();
+        ele2.setId(200);
+
+        treeSet.add(ele1);
+        treeSet.add(ele2);
+
+        System.out.println(treeSet);
+    }
+
+    @Test
+    public void whenUsingHeadSet_shouldReturnElementsLessThanSpecifiedElement() {
+        Set<Element> treeSet = new TreeSet<>(comparator);
+        Element ele1 = new Element();
+        ele1.setId(100);
+        Element ele2 = new Element();
+        ele2.setId(200);
+
+        treeSet.add(ele1);
+        treeSet.add(ele2);
+
+        System.out.println(treeSet);
+    }
+
+    @Test
+    public void whenUsingSubSet_shouldReturnSubSetElements() {
+        SortedSet<Integer> treeSet = new TreeSet<>();
+        treeSet.add(1);
+        treeSet.add(2);
+        treeSet.add(3);
+        treeSet.add(4);
+        treeSet.add(5);
+        treeSet.add(6);
+
+        Set<Integer> expectedSet = new TreeSet<>();
+        expectedSet.add(2);
+        expectedSet.add(3);
+        expectedSet.add(4);
+        expectedSet.add(5);
+
+        Set<Integer> subSet = treeSet.subSet(2, 6);
+        Assert.assertEquals(expectedSet, subSet);
+    }
+
+    @Test
+    public void whenUsingHeadSet_shouldReturnHeadSetElements() {
+        SortedSet<Integer> treeSet = new TreeSet<>();
+        treeSet.add(1);
+        treeSet.add(2);
+        treeSet.add(3);
+        treeSet.add(4);
+        treeSet.add(5);
+        treeSet.add(6);
+
+        Set<Integer> subSet = treeSet.headSet(6);
+        Assert.assertEquals(subSet, treeSet.subSet(1, 6));
+    }
+
+    @Test
+    public void whenUsingTailSet_shouldReturnTailSetElements() {
+        NavigableSet<Integer> treeSet = new TreeSet<>();
+        treeSet.add(1);
+        treeSet.add(2);
+        treeSet.add(3);
+        treeSet.add(4);
+        treeSet.add(5);
+        treeSet.add(6);
+
+        Set<Integer> subSet = treeSet.tailSet(3);
+        Assert.assertEquals(subSet, treeSet.subSet(3, true, 6, true));
+    }
+}
@@ -0,0 +1,70 @@
+package com.baeldung.java.set;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import org.junit.jupiter.api.Test;
+  
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+
+public class HashSetInitalizingUnitTest {
+    @Test
+    public void whenUsingJava_usingArraysStaticMethod_thenCorrectSize() {
+        Set<String> set = new HashSet<>(Arrays.asList("a", "b", "c"));
+        assertEquals(3, set.size());
+    }
+
+    @Test
+    public void whenUsingJava_usingAnonymousClass_thenCorrectSize() {
+        Set<String> set = new HashSet<String>(){{
+            add("a");
+            add("b");
+            add("c");
+        }};
+        assertEquals(3, set.size());
+    }
+
+    @Test
+    public void whenUsingJava_creatingSingletonSet_thenCorrectSize() {
+        Set<String> set = Collections.singleton("a");
+        assertEquals(1, set.size());
+    }
+
+    public static final <T> Set<T> newHashSet(T... objs) {
+        Set<T> set = new HashSet<T>();
+        Collections.addAll(set, objs);
+        return set;
+    }
+
+    @Test
+    public void whenUsingJava_usingCustomStaticUtilMethod_thenCorrectSize() {
+        Set<String> set = newHashSet("a","b","c");
+        assertEquals(3, set.size());
+    }
+
+    @Test
+    public void whenUsingJava8_usingCollectOnStream_thenCorrectSize() {
+        Set<String> set = Stream.of("a", "b", "c").collect(Collectors.toCollection(HashSet::new));
+        assertEquals(3, set.size());
+    }
+
+    @Test
+    public void whenUsingGoogleGuava_createMutableSet_thenCorrectSize() {
+        Set<String> set = Sets.newHashSet("a", "b", "c");
+        assertEquals(3, set.size());
+    }
+
+    @Test
+    public void whenUsingGoogleGuava_createImmutableSet_thenCorrectSize() {
+        Set<String> set = ImmutableSet.of("a", "b", "c");
+        assertEquals(3, set.size());
+    }
+  
+}
+
@@ -0,0 +1,99 @@
+package com.baeldung.java.set;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class SetUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(SetUnitTest.class);
+
+    @Test
+    public void givenTreeSet_whenRetrievesObjects_thenNaturalOrder() {
+        Set<String> set = new TreeSet<>();
+        set.add("Baeldung");
+        set.add("is");
+        set.add("Awesome");
+        assertEquals(3, set.size());
+        assertTrue(set.iterator()
+            .next()
+            .equals("Awesome"));
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenTreeSet_whenAddNullObject_thenNullPointer() {
+        Set<String> set = new TreeSet<>();
+        set.add("Baeldung");
+        set.add("is");
+        set.add(null);
+    }
+
+    @Test
+    public void givenHashSet_whenAddNullObject_thenOK() {
+        Set<String> set = new HashSet<>();
+        set.add("Baeldung");
+        set.add("is");
+        set.add(null);
+        assertEquals(3, set.size());
+    }
+
+    @Test
+    public void givenHashSetAndTreeSet_whenAddObjects_thenHashSetIsFaster() {
+
+        long hashSetInsertionTime = measureExecution(() -> {
+            Set<String> set = new HashSet<>();
+            set.add("Baeldung");
+            set.add("is");
+            set.add("Awesome");
+        });
+
+        long treeSetInsertionTime = measureExecution(() -> {
+            Set<String> set = new TreeSet<>();
+            set.add("Baeldung");
+            set.add("is");
+            set.add("Awesome");
+        });
+
+        LOG.debug("HashSet insertion time: {}", hashSetInsertionTime);
+        LOG.debug("TreeSet insertion time: {}", treeSetInsertionTime);
+    }
+
+    @Test
+    public void givenHashSetAndTreeSet_whenAddDuplicates_thenOnlyUnique() {
+        Set<String> set = new HashSet<>();
+        set.add("Baeldung");
+        set.add("Baeldung");
+        assertTrue(set.size() == 1);
+
+        Set<String> set2 = new TreeSet<>();
+        set2.add("Baeldung");
+        set2.add("Baeldung");
+        assertTrue(set2.size() == 1);
+    }
+
+    @Test(expected = ConcurrentModificationException.class)
+    public void givenHashSet_whenModifyWhenIterator_thenFailFast() {
+        Set<String> set = new HashSet<>();
+        set.add("Baeldung");
+        Iterator<String> it = set.iterator();
+
+        while (it.hasNext()) {
+            set.add("Awesome");
+            it.next();
+        }
+    }
+
+    private static long measureExecution(Runnable task) {
+        long startTime = System.nanoTime();
+        task.run();
+        long endTime = System.nanoTime();
+        long executionTime = endTime - startTime;
+        LOG.debug(String.valueOf(executionTime));
+        return executionTime;
+    }
+}