🔍 Java Collections - Understanding Set Interface with Real-World Use Cases

Series: Java Collections Framework | Part 1 – Set

Hello Devs! 👋
Welcome to the first blog of my Java Collections Framework series. In this post, we’ll deep-dive into the Set interface—its purpose, types, when to use which type, and solve a real-world problem using each variant.

---

🧠 What is a Set in Java?

A Set is a collection that does not allow duplicate elements. It models the mathematical set abstraction, used when we want to store unique values.

Key Features:

• No duplicates allowed.

• May or may not maintain insertion order (depends on the implementation).

• Can store at most one null element (in most implementations).

---

💡 Real-World Problem Statement

“You're building a contact management system. You need to store a list of email addresses, but duplicates should be removed automatically. Depending on your UI/UX design, you might want to preserve the order of entry or sort the emails alphabetically.”

---

🔧 Use Case 1: Remove Duplicate Emails with No Order Guarantee

Solution: Use HashSet

🔸 HashSet:

• Does not maintain insertion order.

• Offers constant-time performance for basic operations like add, remove, and contains.

• Allows one null element.

✅ Code Example:

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> emails = new HashSet<>();

        emails.add("suraj@gmail.com");
        emails.add("info@example.com");
        emails.add("suraj@gmail.com"); // Duplicate
        emails.add("hello@domain.com");

        System.out.println("Unique Emails: " + emails);
    }
}

📌 Output:

Unique Emails: [info@example.com, suraj@gmail.com, hello@domain.com]

⚠️ Notice: Order is not guaranteed.

---

🔧 Use Case 2: Preserve Insertion Order of Emails

Solution: Use LinkedHashSet

🔸 LinkedHashSet:

• Maintains the order in which elements were inserted.

• Slightly slower than HashSet due to the linked list used for ordering.

• Still provides constant-time performance.

✅ Code Example:

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        Set<String> emails = new LinkedHashSet<>();

        emails.add("suraj@gmail.com");
        emails.add("info@example.com");
        emails.add("suraj@gmail.com"); // Duplicate
        emails.add("hello@domain.com");

        System.out.println("Ordered Emails: " + emails);
    }
}

📌 Output:

Ordered Emails: [suraj@gmail.com, info@example.com, hello@domain.com]

✅ Maintains the insertion order.

---

🔧 Use Case 3: Store Emails in Alphabetical Order

Solution: Use TreeSet

🔸 TreeSet:

• Stores elements in sorted (natural) order.

• Does not allow null values.

• Backed by a Red-Black tree, so operations take O(log n) time.

✅ Code Example:

import java.util.Set;
import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        Set<String> emails = new TreeSet<>();

        emails.add("suraj@gmail.com");
        emails.add("info@example.com");
        emails.add("hello@domain.com");
        emails.add("suraj@gmail.com"); // Duplicate

        System.out.println("Sorted Emails: " + emails);
    }
}

📌 Output:

Sorted Emails: [hello@domain.com, info@example.com, suraj@gmail.com]

✅ Automatically sorted alphabetically.

---

🔍 When to Use What?

---

🎯 Summary

• Set is used for unique elements.

• Choose the type of Set based on your needs:

  • Unordered: HashSet

  • Ordered (insertion): LinkedHashSet

  • Ordered (sorted): TreeSet

---

🚀 Coming Up Next

In the next part of this series, we’ll explore the List interface and its implementations like ArrayList, LinkedList, and more with real-life use cases.

Stay tuned and follow me for more posts on Java Collections Framework!
Let me know in the comments if you want a comparison between Set and List, or anything specific about Collections 🚀