Set

🔍 What Is It?

Set Interface

java.util.Set extends Collection but guarantees no duplicates:

• →add(E e) — adds element; returns false if already present
• →contains(Object o) — O(1) for HashSet, O(log n) for TreeSet
• →remove(Object o) — removes element
• →No index-based access (no get(int index))

Key Implementations:

• →HashSet — backed by HashMap; O(1) average add/contains/remove; no ordering guarantee
• →LinkedHashSet — HashSet + doubly-linked list; O(1) operations; preserves insertion order
• →TreeSet — backed by TreeMap (Red-Black tree); O(log n) operations; always sorted; elements must be Comparable or provide Comparator
• →EnumSet — specialized for enum types; extremely fast (bitset internally)
• →Set.of() — immutable set (Java 9+)
• →CopyOnWriteArraySet — thread-safe; backed by CopyOnWriteArrayList

🎯 Why Do We Need It?

Sets solve uniqueness problems:

• →Deduplication — remove duplicates from a list
• →Membership testing — is this user in the admin set? is this email already registered?
• →Set operations — union, intersection, difference (for business logic)
• →Tag systems — user has tags: Set<String> tags; fast contains() check

Critical: for HashSet to work correctly, elements must implement equals() and hashCode() consistently.

🏗️ What Happens in Real Projects?

Common enterprise patterns:

// Deduplication
List<String> withDups = Arrays.asList("a", "b", "a", "c", "b");
Set<String> unique = new LinkedHashSet<>(withDups);  // preserves order
List<String> deduped = new ArrayList<>(unique);

// Permission checking
Set<Permission> userPermissions = user.getPermissions();
if (userPermissions.contains(Permission.ADMIN)) { ... }

// Find common elements (intersection)
Set<String> teamA = Set.of("alice", "bob", "charlie");
Set<String> teamB = Set.of("bob", "charlie", "diana");
Set<String> both = new HashSet<>(teamA);
both.retainAll(teamB);  // {bob, charlie}

⚙️ How It Works

HashSet:

Internally a HashMap<E, PRESENT> — the element is the key. Uses hashCode() to find the bucket, then equals() to check for duplicates. Requires both to be consistent.

TreeSet:

Internally a TreeMap. Elements are sorted using natural ordering (Comparable) or a provided Comparator. Does NOT use equals()/hashCode() — uses compareTo() for equality. Two elements where compareTo() returns 0 are considered equal even if equals() returns false.

Critical: equals() and hashCode() contract:

If a.equals(b) is true, then a.hashCode() must equal b.hashCode(). If you override one, you must override both.

💻 Example

Set Operations in Enterprise Code — Practical Set usage for deduplication, membership, and set operations.

// HashSet — fastest, no order
Set<String> permissions = new HashSet<>();
permissions.add("READ");
permissions.add("WRITE");
permissions.add("READ");  // duplicate — silently ignored
System.out.println(permissions.size());  // 2

// LinkedHashSet — preserves insertion order
Set<String> orderedTags = new LinkedHashSet<>();
orderedTags.add("java");
orderedTags.add("spring");
orderedTags.add("microservices");
orderedTags.add("java");  // duplicate ignored, order preserved
System.out.println(orderedTags);  // [java, spring, microservices]

// Deduplication preserving order
public static <T> List<T> deduplicate(List<T> list) {
    return new ArrayList<>(new LinkedHashSet<>(list));
}

// Set operations
Set<String> admins = new HashSet<>(Set.of("alice", "bob", "charlie"));
Set<String> managers = new HashSet<>(Set.of("bob", "charlie", "diana"));

// Union (all unique elements from both)
Set<String> union = new HashSet<>(admins);
union.addAll(managers);  // {alice, bob, charlie, diana}

// Intersection (elements in both)
Set<String> intersection = new HashSet<>(admins);
intersection.retainAll(managers);  // {bob, charlie}

// Difference (in admins but not managers)
Set<String> difference = new HashSet<>(admins);
difference.removeAll(managers);  // {alice}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits