HashSet Vs HashMap in Java

Last Updated: 22 January, 2023

HashSet and HashMap are both important Collection Framework classes that can be found in the java.util package. There are the following differences between them:

👉 HashSet

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.

Java HashSet Class Declaration

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable

Here, E defines the type of elements that the Set will contain.

Java HashSet important features:

A HashSet's underlying data structure is a hash table (an instance of HashMap).
A HashSet contains only unique elements, which means no duplicates are allowed.
In HashSet, elements are inserted based on their hash code, so no insertion order is preserved.
A HashSet can accept only one NULL element.
The initial capacity of the hash set is 16, and the load factor is.75.
By default, HashSet is not synchronized, which means multiple threads can access the same HashSet object at a time.
HashSet provides fast performance because it uses hashing techniques and gives constant-time performance.
HashSet is the best choice if we perform search operations.

👉 HashMap

The HashMap class was introduced in the Java 1.2 version and is available in the java.util package. HashMap is a child class of the AbstractMap class, and it implements the Map interface as well as the Cloneable and Serializable interfaces.

HashMap is used to store the data in the form of key-value pairs, where keys must be unique and values may be duplicated. HashMap accepts only one null key and multiple null values.

Java HashMap Class Declaration

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

Here, K is the key Object type and V is the value Object type.

Java HashMap important features:

By default, HashMap is a non-synchronized class.
HashMap uses the hash table concept to store the data.
HashMap does not maintain data insertion order.
HashMap's initial capacity is 16, and the load factor is 0.75.
If the application demands faster insertion and retrieval, then HashMap is the ultimate choice.

👉 HashSet and HashMap have the following differences:

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.

👉 Example of HashSet and HashMap in Java

Example 1: A sample Java program of HashSet

  
  import java.util.HashSet;
  public class HashSetExample {
    public static void main(String[] args) {
      // Creating a HashSet
      HashSet<Integer> hashSet = new HashSet<Integer>();
      // 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);
    }
  }

Output

HashSet elements: [800, null, 500, 200]

Example 2: A sample Java program of HashMap

  
  import java.util.HashMap;
  import java.util.Map;
  public class HashMapExample {
    public static void main(String[] args) {
      // Creating HashMap
      HashMap<String, String> map = new HashMap<>();
        
      // Inserting data in the form of key-value pair using put() method
      map.put("in", "India");
      map.put("us", "United State");
      map.put("en", "England");
      map.put("ca", "Canada");
  
      System.out.println("Iterating Hashmap and printing Key and Value");
      for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + " - " + m.getValue());
      }
    }
  }

Output

Iterating Hashmap and printing Key and Value
in - India
en - England
us - United State
ca - Canada

That's all guys, hope this Java article is helpful for you.

Happy Learning... 😀

Please share this article on social media to help others.

If you have any query or suggestion regarding this artical please share with us
feedback@javabytechie.com