HashSet

🔍 What Is It?

HashSet is java.util.Set backed by a HashMap<E, PRESENT> where PRESENT is a static dummy Object.

Key Characteristics:

• →No duplicates — add() returns false if element already present
• →No ordering — iteration order is unpredictable
• →O(1) average for add, remove, contains
• →Allows one null element
• →Not thread-safe

Relationship to HashMap:

// HashSet internally uses:
private transient HashMap<E, Object> map;
private static final Object PRESENT = new Object();

public boolean add(E e) {
    return map.put(e, PRESENT) == null;
}
public boolean contains(Object o) {
    return map.containsKey(o);
}

🎯 Why Do We Need It?

HashSet provides O(1) contains() vs O(n) for List. When you need to check "is this element already seen?" thousands of times, HashSet is the right tool. It is also the natural data structure for sets of unique identifiers, tags, permissions, and visited nodes in graph algorithms.

🏗️ What Happens in Real Projects?

Common enterprise patterns:

// Deduplication
Set<String> processedIds = new HashSet<>();
for (Event event : events) {
    if (processedIds.add(event.getId())) {  // add returns false if duplicate
        process(event);
    }
}

// Permission checking
Set<String> userRoles = user.getRoles();
if (userRoles.contains("ADMIN")) { ... }

// Visited tracking in BFS/DFS
Set<String> visited = new HashSet<>();
Queue<String> queue = new ArrayDeque<>();

⚙️ How It Works

HashSet delegates everything to its backing HashMap. add(e) calls map.put(e, PRESENT). contains(o) calls map.containsKey(o). The same hashCode/equals requirements and collision handling apply.

💻 Example

HashSet in Practice — Practical HashSet usage patterns.

// Basic usage
Set<String> tags = new HashSet<>();
tags.add("java");
tags.add("spring");
tags.add("java");  // duplicate — ignored, returns false
System.out.println(tags.size());  // 2

// Deduplication of a list (preserving order: use LinkedHashSet)
List<Integer> withDups = List.of(3, 1, 4, 1, 5, 9, 2, 6, 5, 3);
List<Integer> unique = new ArrayList<>(new LinkedHashSet<>(withDups));
System.out.println(unique);  // [3, 1, 4, 5, 9, 2, 6]

// Fast membership testing
Set<String> stopWords = new HashSet<>(Set.of(
    "the", "a", "an", "is", "are", "was", "were"
));
// O(1) per check — much faster than List.contains()
String[] words = text.split("\s+");
List<String> meaningful = Arrays.stream(words)
    .filter(w -> !stopWords.contains(w))
    .collect(Collectors.toList());

// Set operations
Set<Long> premiumUsers = new HashSet<>(getPremiumUserIds());
Set<Long> activeUsers = new HashSet<>(getActiveUserIds());

// Intersection: premium AND active
Set<Long> premiumActive = new HashSet<>(premiumUsers);
premiumActive.retainAll(activeUsers);

// Union: premium OR active
Set<Long> either = new HashSet<>(premiumUsers);
either.addAll(activeUsers);

// Difference: premium but NOT active (lapsed subscriptions)
Set<Long> lapsed = new HashSet<>(premiumUsers);
lapsed.removeAll(activeUsers);

🤔 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