🔍 What Is a HashSet?
A HashSet is a collection in Java that stores unique elements — no duplicates allowed.
It’s part of the java.util package and is backed by a HashMap internally.
Think of it like a bag of unique cards 🎴 — if you try to add the same card again, it just ignores it.
⚙️ Quick Example import java.util.HashSet; public class HashSetExample { public static void main(String[] args) { HashSet<String> countries = new HashSet<>(); countries.add("Japan"); countries.add("Canada"); countries.add("Japan"); // duplicate ignored System.out.println(countries); // [Japan, Canada] System.out.println("Contains Canada? " + countries.contains("Canada")); // true } } ✅ Output:
[Japan, Canada] Contains Canada? true 🧠 Notice how “Japan” appears only once — HashSet automatically handles duplicates.
⚙️ How It Works Internally
Under the hood, a HashSet uses a HashMap where:
Elements are stored as keys.
A dummy value (usually a static constant) acts as the value.
When you call add(element):
The element’s hashCode() is computed.
It’s placed into a bucket based on that hash.
If another element has the same hash (collision), it’s stored in a linked list or tree within that bucket.
The equals() method ensures duplicates are not added.
⚙️ Common Methods
| Method | Description |
|---|---|
add(E e) | Adds element if not already present |
remove(Object o) | Removes element |
contains(Object o) | Checks if element exists |
isEmpty() | Returns true if empty |
size() | Returns number of elements |
clear() | Removes all elements |
🧮 Time Complexity
| Operation | Average | Worst Case |
|---|---|---|
| add() | O(1) | O(n) |
| remove() | O(1) | O(n) |
| contains() | O(1) | O(n) |
| iteration | O(n) | O(n) |
⚡ HashSet provides constant-time performance for most operations — that’s why it’s widely used for lookups and membership checks.
💡 Key Features
🚫 No duplicates — each element is unique.
⚡ Fast lookup using hashing.
🔀 No guaranteed order — iteration order may differ from insertion order.
📦 Allows one null element.
❌ Not thread-safe — use Collections.synchronizedSet() for concurrency.
🔍 Example: Removing Duplicates from a List
import java.util.*; public class RemoveDuplicates { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5); HashSet<Integer> unique = new HashSet<>(numbers); System.out.println(unique); // [1, 2, 3, 4, 5] } } 👉 This is one of the most common and elegant uses of a HashSet.
🔍 Example: Checking Membership Efficiently
HashSet<String> users = new HashSet<>(); users.add("mohammed"); users.add("ahmed"); if (users.contains("mohammed")) { System.out.println("Welcome back!"); } This operation is instant (O(1)) — much faster than searching a list.
🧩 HashSet vs TreeSet vs LinkedHashSet
| Feature | HashSet | LinkedHashSet | TreeSet |
|---|---|---|---|
| Order | No order | Maintains insertion order | Sorted order |
| Speed | Fastest | Slightly slower | Slower (due to sorting) |
| Backed By | HashMap | LinkedHashMap | TreeMap |
| Allows Null | Yes | Yes | No |
| Use Case | Unordered unique items | Preserve insertion order | Sorted unique items |
🌍 Real-World Uses of HashSet
- 🧾 Removing Duplicates
Cleaning up data — for example, user emails or IDs that appear multiple times.
- 🔐 Checking Membership
Efficient “already exists?” checks (e.g., registered usernames, cached results).
- 🧠 Tracking Unique Events
Game achievements, visited URLs, or user actions that should happen only once.
- 🗃 Efficient Lookup Tables
Fast lookups for values without caring about order — like tags, keywords, or filters.
⚙️ Example: Unique Visitors in a Web App
import java.util.HashSet; public class UniqueVisitors { public static void main(String[] args) { HashSet<String> visitors = new HashSet<>(); visitors.add("user123"); visitors.add("guest456"); visitors.add("user123"); // duplicate System.out.println("Unique visitors: " + visitors.size()); } } ✅ Output:
Unique visitors: 2
⚠️ Common Mistakes
❌ Expecting insertion order — HashSet does not maintain it.
❌ Forgetting to override hashCode() and equals() in custom objects.
❌ Using mutable objects as keys — changing them breaks hash consistency.
🧩 Example: Custom Object in HashSet
import java.util.*; class Student { String name; int id; Student(String name, int id) { this.name = name; this.id = id; } @Override public int hashCode() { return Objects.hash(id); } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Student)) return false; Student s = (Student) o; return id == s.id; } } public class CustomHashSet { public static void main(String[] args) { HashSet<Student> set = new HashSet<>(); set.add(new Student("Ali", 1)); set.add(new Student("Ali", 1)); // duplicate ignored System.out.println("Total students: " + set.size()); // 1 } } Without overriding hashCode() and equals(), this would incorrectly count as 2 students.
💡 Final Thought
The HashSet is your go-to structure when you want uniqueness and speed without worrying about order.
It’s one of the fastest and most memory-efficient collections in Java — a real workhorse behind the scenes of many high-performance systems. ⚡
Top comments (0)