BAEL-8986 A Guide to HashSet in Java (#18081)

* Update WhenUsingHashSet.java

* Create Employee.java

* Update pom.xml

* Update WhenUsingHashSet.java

* Update Employee.java

* Update WhenUsingHashSet.java

Author: Deepak-Vohra

core-java-modules/core-java-collections-set/pom.xml

@@ -14,6 +14,13 @@
     </parent>
 
     <dependencies>
+        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.11.3</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-collections4</artifactId>
@@ -44,4 +51,4 @@
         <gson.version>2.11.0</gson.version>
     </properties>
 
-</project>
+</project>

core-java-modules/core-java-collections-set/src/test/java/com/baeldung/collection/Employee.java

@@ -0,0 +1,35 @@
+package com.baeldung.collection;
+
+public class Employee implements Comparable<Employee> {
+    private int employeeId;
+    private String employeeName;
+
+    Employee(int employeeId, String employeeName) {
+        this.employeeId = employeeId;
+        this.employeeName = employeeName;
+    }
+
+    int getEmployeeId() {
+        return employeeId;
+    }
+
+    public String getEmployeeName() {
+        return employeeName;
+    }
+
+    @Override
+    public String toString() {
+        return employeeId + " " + employeeName;
+    }
+
+    @Override
+    public int compareTo(Employee o) {
+        if (this.employeeId == o.employeeId) {
+            return 0;
+        } else if (this.employeeId < o.employeeId) {
+            return 1;
+        } else {
+            return -1;
+        }
+    }
+}

core-java-modules/core-java-collections-set/src/test/java/com/baeldung/collection/WhenUsingHashSet.java

@@ -1,54 +1,62 @@
 package com.baeldung.collection;
 
+import org.junit.jupiter.api.Test; 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.util.ConcurrentModificationException;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
-
-import org.junit.Assert;
-import org.junit.Test;
+import java.util.TreeSet;
+ 
 
 public class WhenUsingHashSet {
 
+    private static HashSet<Employee> hashSet;
+    private static TreeSet<Employee> treeSet;
+    
     @Test
     public void whenAddingElement_shouldAddElement() {
         Set<String> hashset = new HashSet<>();
-        Assert.assertTrue(hashset.add("String Added"));
+        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"));
+        assertTrue(hashsetContains.contains("String Added"));
     }
 
     @Test
     public void whenCheckingTheSizeOfHashSet_shouldReturnThesize() {
         Set<String> hashSetSize = new HashSet<>();
         hashSetSize.add("String Added");
-        Assert.assertEquals(1, hashSetSize.size());
+        assertEquals(1, hashSetSize.size());
     }
 
     @Test
     public void whenCheckingForEmptyHashSet_shouldCheckForEmpty() {
         Set<String> emptyHashSet = new HashSet<>();
-        Assert.assertTrue(emptyHashSet.isEmpty());
+        assertTrue(emptyHashSet.isEmpty());
     }
 
     @Test
     public void whenRemovingElement_shouldRemoveElement() {
         Set<String> removeFromHashSet = new HashSet<>();
         removeFromHashSet.add("String Added");
-        Assert.assertTrue(removeFromHashSet.remove("String Added"));
+        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());
+        assertTrue(clearHashSet.isEmpty());
     }
 
     @Test
@@ -63,17 +71,19 @@ public void whenIteratingHashSet_shouldIterateHashSet() {
         }
     }
 
-    @Test(expected = ConcurrentModificationException.class)
+    @Test
     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()) {
+        assertThrows(ConcurrentModificationException.class,() -> { 
+          while (itr.hasNext()) {
             itr.next();
             hashset.remove("Second");
-        }
+          } 
+        });
     }
 
     @Test
@@ -88,6 +98,38 @@ public void whenRemovingElementUsingIterator_shouldRemoveElement() {
             if (element.equals("Second"))
                 itr.remove();
         }
-        Assert.assertEquals(2, hashset.size());
+        assertEquals(2, hashset.size());
+    }
+
+    @Test
+    public void givenNonComparableObject_whenConvertingToTreeSet_thenExceptionThrown() {
+
+        HashSet<Employee> hashSet = new HashSet<Employee>();
+        
+        hashSet.add(new Employee(3, "John"));
+        hashSet.add(new Employee(5, "Mike"));
+        hashSet.add(new Employee(2, "Bob"));
+        hashSet.add(new Employee(1, "Tom"));
+        hashSet.add(new Employee(4, "Johnny"));  
+        
+        assertThrows(ClassCastException.class,() -> { 
+          TreeSet<Employee> treeSet = new TreeSet<Employee>(hashSet); 
+        });
+    }
+
+    @Test
+    public void givenComparableObject_whenConvertingToTreeSet_thenNoExceptionThrown() {
+
+        HashSet<Employee> hashSet = new HashSet<Employee>();
+        
+        hashSet.add(new Employee(3, "John"));
+        hashSet.add(new Employee(5, "Mike"));
+        hashSet.add(new Employee(2, "Bob"));
+        hashSet.add(new Employee(1, "Tom"));
+        hashSet.add(new Employee(4, "Johnny"));  
+        
+        assertDoesNotThrow(()->{
+            TreeSet<Employee> treeSet=new TreeSet<Employee>(hashSet);
+        });
     }
 }