Java HashSet Class

The HashSet class is a member of the Java Collection Framework. HashSet was introduced in the JDK 1.2 version and is available in the java.util package.

A HashSet is used to create an unordered collection of elements that contains only unique elements; no duplicate elements are allowed. The HashSet provides constant-time performance for general operations such as add, remove, contain, size, etc.

HashSet's internal implementation is based on the hash table for creating and storing a collection of unique elements.

Hash table: Actually, hash table is an instance of the HashMap class that uses a hashing mechanism for storing the information within a HashSet.

Hashing and HashCode: Hashing is the technique of mapping keys and values into the hash table by using a hash function. It is done for faster access to elements. The efficiency of mapping depends on the efficiency of the hash function used.
The hash code is an integer value associated with each object. It is used to identify the location of objects in the hash table. The hashCode() method is used to return the hash code value of the object in Java.

👉 Java HashSet important points:

👉 Java HashSet Class Hierarchy

As we can see from the complete hierarchy above, HashSet extends the AbstractSet class and implements the Set interface as well as the Serializable and Cloneable interfaces.

👉 Java HashSet Class Declaration

👉 Java HashSet Class Example

  
  import java.util.HashSet;
  public class HashSetExample {
    public static void main(String[] args) {
      // Creating a HashSet
      HashSet hashSet = new HashSet<>();
      // Adding elements into the HashSet
      hashSet.add(800);
      hashSet.add(500);
      hashSet.add(null); // Adding null as an element
      hashSet.add(200);
      hashSet.add(500); // Adding duplicate element
      // Printing HashSet elements
      System.out.println("HashSet elements: " + hashSet);
    }
  }

👉 Java HashSet Class Constructors

👉 Java HashSet Class Methods

HashSet Class Methods Examples

The Java HashSet class provided methods are implemented in the below given examples. Let's go through the examples one by one and understand the uses for each method.

Example 1: Methods for Adding elements in HashSet

Before inserting the elements into the HashSet please note that insertion order is not preserved and also that duplicate elements are not allowed, but one null can be inserted.

Constructor Name & Descriptions
public HashSet() This construct is used to create a new and empty HashSet object with a default initial capacity is 16 and a load factor is 0.75 HashSet<E> hs = new HashSet<E>();
public HashSet(int initialCapacity) This constructor is used to create a new and empty HashSet object in which the initial capacity is specified in the construct parameter and default load factor (0.75) HashSet<E> hs = new HashSet<E>(int initialCapacity); It will throw IllegalArgumentException if the initial capacity is less than zero.
public HashSet(int initialCapacity, float loadFactor) This constructor is used to create a new and empty HashSet object in which the initialCapacity and loadFactor are specified in the construct parameters. HashSet<E> hs = new HashSet<E>(int initialCapacity, float loadFactor); Note: It will throw IllegalArgumentException if the initial capacity value is less than zero, or if the load factor is nonpositive value.
public HashSet(Collection<? extends E> c) This constructor is used to create a HashSet object which contains the elements in the specified collection with a default load factor (0.75) and an initial capacity sufficient to contain the elements in the specified collection. HashSet<E> hs = new HashSet<E>(Collection C); Note: It will throw NullPointerException if the specified collection is null.

Method	Description
public boolean add(E e)	Adds element to the set if it is not already present. Returns true if the set did not already contain the specified element otherwise return false.
public boolean remove(Object o)	Removes the specified element from this set if it is present. Returns true if the set contained the specified element otherwise return false.
public void clear()	Removes all of the elements from this set. The set will be empty after this call returns.
public Object clone()	Returns a shallow copy of this HashSet instance: the elements themselves are not cloned.
public boolean contains(Object o)	Returns true if this set contains the specified element otherwise return false.
public boolean isEmpty()	Returns true if this set contains no elements otherwise return false.
public int size()	Returns the number of elements in this set (its cardinality).
public Iterator<E> iterator()	Returns an iterator over the elements in this set. The elements are returned in no particular order.
public Spliterator<E> spliterator()	Creates a late-binding and fail-fast Spliterator over the elements in this set.

              
  import java.util.Arrays;
  import java.util.HashSet;
  public class AddElementsInHashSet {
    public static void main(String[] args) {
    
      /******************************************
      HashSet - add(), addAll() Methods Example
      *******************************************/
      
      // Creating a HashSet
      HashSet<Integer> hashSet = new HashSet<>();
        
      // Adding elements into the HashSet
      hashSet.add(800);
      hashSet.add(500);
      hashSet.add(null);   // Adding null as an element
      hashSet.add(200);
      hashSet.add(500);    // Adding duplicate element
      
      // Printing HashSet elements
      System.out.println("HashSet elements");
      System.out.println(hashSet);
      
      // Creating another HashSet and adding elements
      HashSet<Integer> hashSetSecond = new HashSet<>(Arrays.asList(10, 20, 30, 40));
        
      // Adding HashSet into another HashSet
      hashSet.addAll(hashSetSecond);
      
      // Printing HashSet elements
      System.out.println("\nHashSet elements after adding another HashSet");
      System.out.println(hashSet);
    }
  }

HashSet elements
[800, null, 500, 200]

HashSet elements after adding another HashSet
[800, null, 500, 20, 200, 40, 10, 30]

Example 2 : Methods for Deleting elements from HashSet

              
  import java.util.Arrays;
  import java.util.HashSet;
  public class RemoveElementsFromHashSet {
    public static void main(String[] args) {
      /*************************************************************************
      HashSet - remove(), removeAll(), removeIf(), retainAll() Methods Example
      **************************************************************************/
      
      // Creating and adding elements into HashSet
      HashSet<Integer> hashSet = new HashSet<>(Arrays.asList(10, 20, 30, 40, 50, 60, 70));
      System.out.println("HashSet elements: " + hashSet);
      
      // Removing the specified element from HashSet
      hashSet.remove(40);
      System.out.println("After calling remove() method: " + hashSet);
      
      // Creating another HashSet and adding elements
      HashSet<Integer> hashSetSecond = new HashSet<>(Arrays.asList(20, 60, 70));
        
      // Removing all those elements that matches with second HashSet elements
      hashSet.removeAll(hashSetSecond);
      System.out.println("After calling removeAll() method: " + hashSet);
      
      // Removing elements on the basis of specified condition  
      hashSet.removeIf(i -> i == 10);    
      System.out.println("After calling removeIf() method: "+ hashSet);
      
      // Removes from the HashSet all of its elements that are not contained in the specified collection
      hashSet.retainAll(hashSetSecond);
      System.out.println("After calling retainingAll() method: " + hashSet);
      
      // Removing all the elements from the HashSet
      hashSet.addAll(hashSetSecond);
      System.out.println("HashSet before calling clear() method: " + hashSet);
      
      // Removing all the elements from the HashSet
      hashSet.clear();
      System.out.println("After calling clear() method: " + hashSet);
    }
  }

HashSet elements: [50, 20, 70, 40, 10, 60, 30]
After calling remove() method: [50, 20, 70, 10, 60, 30]
After calling removeAll() method: [50, 10, 30]
After calling removeIf() method: [50, 30]
After calling retainingAll() method: []
HashSet before calling clear() method: [20, 70, 60]
After calling clear() method: []

Example 3 : Methods for access elements from HashSet

              
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.Iterator;
  public class AccessElementsFromHashSet {
    public static void main(String[] args) {
      
      // Creating and adding elements into HashSet
      HashSet<Integer> hashSet = new HashSet<>(Arrays.asList(10, 20, 30, 40, 50));
      System.out.println("HashSet elements: " + hashSet);
      
      // Access HashSet using Iterator
      Iterator<Integer> num = hashSet.iterator();
      while (num.hasNext())
      System.out.println(num.next());
      
      // Access HashSet using for loop
      for (Integer i : hashSet)
      System.out.println(i);
    }
  }

Example 4 : Utility methods of HashSet Class

              
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashSet;
  public class HashSetUtilityMethods {
    public static void main(String[] args) {
        
      // Creating and adding elements into HashSet
      HashSet<Integer> hashSet = new HashSet<>(Arrays.asList(50, 30, 70, 10, 40, 20, 80));
      System.out.println("HashSet elements: " + hashSet);
      
      // Printing HashSet Size
      System.out.println("HashSet Size: " + hashSet.size());
      
      // Returns true if the HashSet contains no elements.
      System.out.println("Is HashSet Empty: " + hashSet.isEmpty());
      
      // Returns true if the HashSet contains the specified element
      System.out.println("HashSet contains() method: " + hashSet.contains(40));
      
      // Creating another HashSet and adding elements
      HashSet<Integer> hashSetSecond = new HashSet<>(Arrays.asList(20, 60, 70));
        
      // Returns true if the HashSet contains all of the elements of the specified collection
      System.out.println("HashSet containsAll() method: " + hashSet.containsAll(hashSetSecond));
      
      // Converting HashSet into ArrayList
      ArrayList<Integer> arrayList = new ArrayList<>(hashSet);
      System.out.println("ArrayList elements: " + arrayList);
    }
  }

HashSet elements: [80, 50, 20, 70, 40, 10, 30]
HashSet Size: 7
Is HashSet Empty: false
HashSet contains() method: true
HashSet containsAll() method: false
ArrayList elements: [80, 50, 20, 70, 40, 10, 30]

HashSet	HashMap
HashSet implements the Set interface.	HashMap implements the Map interface.
HashSet is an unordered collection of elements that contains only unique elements.	HashMap stores elements in the form of key and value pairs and, keys must be unique. If the key is duplicated then the old key is replaced with the new value.
HashSet implements Set, Cloneable, Serializable, Iterable and Collection interfaces.	HashMap implements Map, Cloneable, and Serializable interfaces.
HashSet requires just one parameter for its object initialization.	HashMap requires two parameters (key and value) for its object initialization.
HashSet can contain a single null value.	HashMap can contain a single null key and no restriction on any number of null values.
For additing the element we use add() method.	Here, we use the put() method for adding an element.
HashSet internally uses the HashMap object to store or add objects.	HashMap internally uses hashing to store or add objects.
HashSet performance is slower than HashMap.	HashMap performance is faster than HashSet.

HashSet	LinkedHashSet
The underlying data structure is a hash table.	The underlying data structure is a hash table + linked list (doubly linked list).
Insertion order is not preserved.	Insertion order is preserved.
HashSet requires less memory than the LinkedHashSet.	LinkedHashSet requires more memory than the HashSet.
HashSet is a parent class of LinkedHashSet.	LinkedHashSet is a child class of HashSet.
Introduced in JDK 1.2 Version.	Introduced in JDK 1.4 Version.

HashSet Class in Java

👉 Java HashSet important points: