HashSet in Java

Introduction

HashSet in Java, HashSet in Java is a powerful data structure that stores a collection of unique elements, ensuring that no duplicates are allowed. It is a part of the Java Collections Framework and is widely used for tasks where uniqueness matters and fast lookups are needed. Behind the scenes, HashSet is backed by a HashMap, using a technique called hashing to store elements efficiently. Unlike lists or arrays where elements are ordered and can be duplicated, HashSet does not maintain any order of elements and automatically ignores duplicate insertions. It can store one null value, and operations like adding, removing, and searching are generally performed in constant time. Overall, HashSet is ideal when you need to maintain a collection of distinct elements with quick access and no concern for order.

List of Content

• What is HashSet?
• Why Use HashSet?
• Key Features of HashSet
• How HashSet Works Internally
• Creating and Initializing a HashSet
• Common Operations in HashSet
• Important Methods in HashSet
• Null Values in HashSet
• Iterating Through a HashSet
• HashSet vs Other Set Implementations (LinkedHashSet, TreeSet)
• Conclusion

🔍 What is HashSet?

A HashSet in Java is a collection that stores only unique elements and does not allow duplicates. It is part of the Java Collections Framework and implements the Set interface. Internally, it is backed by a HashMap, which uses hashing to store elements efficiently. Unlike lists or arrays, a HashSet does not maintain any order of elements. It allows storing one null value and provides constant-time performance for most basic operations like adding, removing, and checking if an element exists.

🤔 Why Use HashMap?

• No duplicates – Automatically ignores duplicate insertions.
• Fast operations – Adding, removing, and searching are generally O(1).
• Best for membership tests – Quickly check if an element exists.
• Lightweight – Does not store extra indexing information.

🌟 Key Features of HashSet:

• Stores unique elements only.
• Does not guarantee order of elements.
• Backed by a HashMap internally.
• Allows one null value.
• Not thread-safe (needs synchronization for multi-threading).
• Offers constant-time complexity for most basic operations.

⚙️ How HashSet Works Internally:

• When an element is added, its hashCode is calculated.
• Based on the hash code, the element is stored in a corresponding bucket of the internal HashMap.
• If another element with the same hash code is added, equals() is used to check for equality.
• If equal, it is ignored (duplicate). If not equal, it is stored in the same bucket but still remains unique.

🛠 Creating ans Initializing a HashSet:

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> fruits = new HashSet<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Mango");
        System.out.println(fruits);
    }
}

🔄 Comman Operations in HashSet:

fruits.add("Orange");       // Add element
fruits.remove("Banana");    // Remove element
fruits.contains("Apple");   // Check if exists
fruits.size();              // Get total elements
fruits.clear();             // Remove all elements

📚 Important methods in HashSet:

• add(E element) – Adds an element.
• remove(Object o) – Removes an element if present.
• contains(Object o) – Checks if element exists.
• isEmpty() – Checks if set is empty.
• size() – Returns total elements.
• clear() – Removes all elements.

🟡 Null Values in HashSet:

• HashSet allows only one null value.
• If you try adding null multiple times, it will still store just one.

Let's Take an Example with dry run:

import java.util.*;

public class HashSetMethodsDemo {
    public static void main(String[] args) {
        // CREATE A HASHSET
        HashSet<String> set = new HashSet<>();

        // add() - ADD ELEMENTS
        set.add("Apple");
        set.add("Banana");
        set.add("Mango");
        set.add("Orange");
        set.add("Apple"); // DUPLICATE, WILL BE IGNORED

        // DISPLAY THE SET
        System.out.println("HashSet: " + set);

        // contains() - CHECK IF ELEMENT EXISTS
        System.out.println("Contains 'Banana'? " + set.contains("Banana")); // TRUE

        // remove() - REMOVE AN ELEMENT
        set.remove("Mango");
        System.out.println("After removing 'Mango': " + set);

        // size() - GET TOTAL ELEMENTS
        System.out.println("Size of HashSet: " + set.size());

        // isEmpty() - CHECK IF EMPTY
        System.out.println("Is HashSet empty? " + set.isEmpty());

        // ITERATING USING FOR-EACH LOOP
        System.out.println("Iterating using for-each loop:");
        for (String fruit : set) {
            System.out.println(fruit);
        }

        // ITERATING USING ITERATOR
        System.out.println("Iterating using Iterator:");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        // clear() - REMOVE ALL ELEMENTS
        set.clear();
        System.out.println("After clearing: " + set);
    }
}

INITIAL STATE

• set is created → [] (empty HashSet)

STEP 1: ADD ELEMENTS:

set.add("Apple");

• Adds "Apple" → ["Apple"]

set.add("Banana");

• Adds "Banana" → ["Apple", "Banana"]

set.add("Mango");

• Adds "Mango" → ["Apple", "Banana", "Mango"]

set.add("Orange");

• Adds "Orange" → ["Apple", "Banana", "Mango", "Orange"]

set.add("Apple"); // Duplicate

• "Apple" already exists → Ignored
• HashSet does not allow duplicates.
  Current set: ["Apple", "Banana", "Mango", "Orange"]
  (Order may vary because HashSet is unordered.)

STEP 2: CHECK CONTAINS:

set.contains("Banana");

• "Banana" is present → returns true.

STEP 3: REMOVE ELEMENT:

set.remove("Mango");

• Removes "Mango" → ["Apple", "Banana", "Orange"]

STEP 4: SIZE:

set.size();

• Current size → 3.

STEP 5: CHECK EMPTY:

set.isEmpty();

• Set has elements → returns false.

STEP 6: CLEAR ALL ELEMENTS:

set.clear();

• Set becomes empty → [].

🔁 Iterating Through HashMap:

for (String fruit : fruits) {
    System.out.println(fruit);
}

// OR using Iterator
Iterator<String> it = fruits.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

🔍 HashSet vs Other Set Implementations:

✅ CONCLUSION:

HashSet is a great choice when you need a collection of unique elements with fast access and no concern for order. It’s lightweight, efficient, and perfect for scenarios like removing duplicates, membership checks, and building sets of data without extra overhead.

Happy Learning! 🚀

👉 For more blogs and topics, Click Here.