Different Java’s Set Implementations

The Set interface in Java is implemented by multiple classes, each with unique characteristics. Below is a detailed comparison of all Set implementations.

1. HashSet

  • Underlying Data Structure: Hash table (HashMap internally).
  • Order: ❌ No guaranteed order.
  • Duplicates: ❌ Not allowed.
  • Null Values: ✅ Allows one null value.
  • Time Complexity:
  • O(1) for insert, delete, and search (on average).
  • O(n) in the worst case (if hash collisions occur).
  • Best Use Case: When fast operations and uniqueness matter, but order does not.

🔹 Example:

Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Mango");
System.out.println(hashSet); // Order is unpredictable

✅ Pros:

  • Fast operations O(1).
  • Allows null values.
  • Best for large sets of data.

❌ Cons:

  • No ordering.
  • Performance drops if hash collisions occur.

2. LinkedHashSet (Extends HashSet)

  • Underlying Data Structure: Hash table + Doubly linked list.
  • Order: ✅ Maintains insertion order.
  • Duplicates: ❌ Not allowed.
  • Null Values: ✅ Allows one null value.
  • Time Complexity:
  • O(1) for insert, delete, and search (on average).
  • O(n) in the worst case.
  • Best Use Case: When you need fast operations but also want to preserve insertion order.

🔹 Example:

Set<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("Apple");
linkedHashSet.add("Banana");
linkedHashSet.add("Mango");
System.out.println(linkedHashSet); // Output: [Apple, Banana, Mango] (Insertion order preserved)

✅ Pros:

  • Maintains insertion order.
  • Fast lookup and insertions.

❌ Cons:

  • Slightly more memory overhead due to the linked list.
  • Slightly slower than HashSet.

3. TreeSet (Implements NavigableSet)

  • Underlying Data Structure: Red-Black Tree (Self-balancing BST).
  • Order: ✅ Sorted order (natural or custom Comparator).
  • Duplicates: ❌ Not allowed.
  • Null Values: ❌ Not allowed (since Java 7).
  • Time Complexity:
  • O(log n) for insert, delete, and search.
  • Best Use Case: When sorted order is needed.

🔹 Example:

Set<Integer> treeSet = new TreeSet<>();
treeSet.add(5);
treeSet.add(1);
treeSet.add(10);
System.out.println(treeSet); // Output: [1, 5, 10] (Sorted order)

✅ Pros:

  • Automatically sorts elements.
  • Provides higher(), lower(), ceiling(), floor() methods.

❌ Cons:

  • Slower than HashSet and LinkedHashSet (O(log n) operations).
  • Does not allow null values.

4. EnumSet (Optimized for Enums)

  • Underlying Data Structure: Bitwise operations (very memory-efficient).
  • Order: ✅ Maintains natural order (Enum ordinal order).
  • Duplicates: ❌ Not allowed.
  • Null Values: ❌ Not allowed.
  • Time Complexity:
  • O(1) for insert, delete, and search.
  • Best Use Case: When working with enum values.

🔹 Example:

enum Days { MONDAY, TUESDAY, WEDNESDAY }
Set<Days> enumSet = EnumSet.of(Days.MONDAY, Days.WEDNESDAY);
System.out.println(enumSet); // Output: [MONDAY, WEDNESDAY]

✅ Pros:

  • Extremely fast and memory-efficient.
  • Best choice for enum types.

❌ Cons:

  • Only works with enums.
  • Does not allow null values.

5. ConcurrentSkipListSet (Thread-safe, Sorted Set)

  • Underlying Data Structure: Skip List.
  • Order: ✅ Sorted order (natural or custom Comparator).
  • Duplicates: ❌ Not allowed.
  • Null Values: ❌ Not allowed.
  • Thread Safety: ✅ Thread-safe.
  • Time Complexity:
  • O(log n) for insert, delete, and search.
  • Best Use Case: When a sorted, thread-safe set is needed.

🔹 Example:

Set<Integer> concurrentSet = new ConcurrentSkipListSet<>();
concurrentSet.add(3);
concurrentSet.add(1);
concurrentSet.add(2);
System.out.println(concurrentSet); // Output: [1, 2, 3] (Sorted)

✅ Pros:

  • Thread-safe.
  • Maintains sorted order.

❌ Cons:

  • Slower than HashSet and LinkedHashSet.
  • More memory overhead.

When to Use Which?

Summary:

  • Use HashSet when fast performance is required and order doesn’t matter.
  • Use LinkedHashSet when insertion order needs to be maintained.
  • Use TreeSet when sorted order is required.
  • Use EnumSet when working with enum values.
  • Use ConcurrentSkipListSet when thread safety and sorting are required.

📚 Want to go deeper?

Grab these resources: 🛒 Full Editions (use code FRIENDS20 for 20% off):
Grokking the Java Interview: link
Grokking the Spring Boot Interview: link
250+ Spring Professional Certification Practice Questions: link
🆓 Try before you buy — Free Sample Copies:
Grokking the Java Interview [Free Sample Copy]
Grokking the Spring Boot Interview [Free Sample Copy]
Spring Boot Certification Practice Questions [Free Sample Copy]

Different Java’s Set Implementations was originally published in Javarevisited on Medium, where people are continuing the conversation by highlighting and responding to this story.

This post first appeared on Read More

Related Posts