[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":87,"_73":88,"_35":89},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":72},"id",107,"title","EnumSet and LinkedHashSet","slug","java-collections-part-11-enumset-linkedhashset","excerpt","Discover EnumSet's blazing-fast bit vector implementation, LinkedHashSet's insertion-order preservation, and when specialized sets outperform general-purpose alternatives.","# Java Collections Compendium Part 11: EnumSet & LinkedHashSet - Specialized Power\n\nDiscover specialized set implementations that outperform general-purpose alternatives. EnumSet uses bit manipulation for blazing speed with enums, while LinkedHashSet preserves insertion order for predictable iteration.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| **Topic** | EnumSet, LinkedHashSet, CopyOnWriteArraySet |\n| **Complexity** | Intermediate |\n| **Prerequisites** | Part 9 (HashSet Internals), Part 10 (TreeSet) |\n| **Time to Master** | 2-3 hours |\n| **Interview Frequency** | Medium (EnumSet performance, LinkedHashSet ordering) |\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. Understand EnumSet's bit vector implementation and extreme performance\n2. Use LinkedHashSet for predictable iteration order\n3. Choose the right specialized set for your use case\n4. Leverage CopyOnWriteArraySet for concurrent read-heavy scenarios\n5. Combine specialized sets with proper design patterns\n\n---\n\n## Production Story: The Permission System Memory Crisis\n\n### The Incident\n\nOur user permission system was running out of memory. Each user had a Set of permissions, and with 100,000 active users, the JVM was struggling.\n\n```java\n// PermissionManager.java - The memory hog\npublic class UserSession {\n private Set permissions = new HashSet<>();\n\n public void grantPermission(Permission p) {\n permissions.add(p);\n }\n\n public boolean hasPermission(Permission p) {\n return permissions.contains(p);\n }\n}\n\n// Permission enum with 32 values\npublic enum Permission {\n READ, WRITE, DELETE, CREATE, ADMIN,\n VIEW_REPORTS, EXPORT_DATA, MANAGE_USERS,\n // ... 24 more permissions\n}\n```\n\n### The Memory Problem\n\nLet's calculate the memory usage:\n\n```java\n// HashSet for ONE user:\n// - HashSet object: ~48 bytes\n// - HashMap (backing): ~48 bytes\n// - HashMap.Entry[] array: ~16 + 8*capacity bytes\n// - Each Entry: ~32 bytes (hash, key, value, next)\n// For 10 permissions: ~500 bytes per user\n\n// 100,000 users × 500 bytes = 50 MB just for permissions!\n// And that's conservative - actual overhead is often higher\n```\n\n### The EnumSet Solution\n\n```java\n// PermissionManager.java - The memory-efficient version\npublic class UserSession {\n private EnumSet permissions = EnumSet.noneOf(Permission.class);\n\n public void grantPermission(Permission p) {\n permissions.add(p);\n }\n\n public boolean hasPermission(Permission p) {\n return permissions.contains(p);\n }\n}\n\n// EnumSet memory for ONE user:\n// - RegularEnumSet object: ~24 bytes\n// - Single long field: 8 bytes (stores ALL permissions as bits!)\n// Total: ~32 bytes per user\n\n// 100,000 users × 32 bytes = 3.2 MB\n// Memory reduction: 94%!\n```\n\n### How EnumSet Works\n\n```text\nPermission enum (32 values):\nREAD=0, WRITE=1, DELETE=2, CREATE=3, ... ADMIN=31\n\nUser has: READ, WRITE, ADMIN\n\nEnumSet storage (single long):\n┌─────────────────────────────────────────────────────────────────────┐\n│ Bit: 31 30 29 28 ... 4 3 2 1 0 │\n│ ↓ ↓ ↓ ↓ │\n│ 1 0 0 0 ... 0 0 0 1 1 = 0x80000003 │\n│ ↑ ↑ ↑ │\n│ ADMIN WRITE READ │\n└─────────────────────────────────────────────────────────────────────┘\n\nOperations:\n• add(WRITE): elements |= (1L << 1) // Set bit 1\n• remove(READ): elements &= ~(1L << 0) // Clear bit 0\n• contains(X): (elements & (1L << X.ordinal())) != 0\n• size(): Long.bitCount(elements) // Count set bits\n\nAll operations are O(1) with single CPU instruction!\n```\n\n### Performance Comparison\n\n```java\n// Benchmark: 1 million contains() operations\nSet hashSet = new HashSet<>(Arrays.asList(Permission.values()));\nEnumSet enumSet = EnumSet.allOf(Permission.class);\n\n// HashSet: ~50ms\nfor (int i = 0; i < 1_000_000; i++) {\n hashSet.contains(Permission.READ);\n}\n\n// EnumSet: ~5ms (10x faster!)\nfor (int i = 0; i < 1_000_000; i++) {\n enumSet.contains(Permission.READ);\n}\n```\n\n### Lessons Learned\n\n1. **EnumSet is always better than HashSet** - no exceptions\n2. **Bit manipulation is faster than hashing**\n3. **Memory savings compound** with many instances\n4. **Check your enum sets** - easy performance win\n\n---\n\n## Mental Model: The Specialized Set Family\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ SPECIALIZED SET FAMILY │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ General Purpose (use when you don't need anything special) │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ HashSet - Fast O(1), unordered │ │\n│ │ TreeSet - Sorted O(log n), navigable │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ Specialized (use when characteristics match your needs) │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ EnumSet - Enums only, blazing fast, tiny memory │ │\n│ │ LinkedHashSet - Insertion order preserved │ │\n│ │ CopyOnWriteArraySet - Thread-safe, read-optimized │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ Decision Tree: │\n│ │\n│ Is it an enum? ─────Yes────→ EnumSet (always!) │\n│ │ │\n│ No │\n│ ↓ │\n│ Need iteration order? ─Yes─→ LinkedHashSet (insertion order) │\n│ │ TreeSet (sorted order) │\n│ No │\n│ ↓ │\n│ Concurrent reads? ────Yes──→ CopyOnWriteArraySet │\n│ │ ConcurrentHashMap.newKeySet() │\n│ No │\n│ ↓ │\n│ HashSet (default choice) │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Deep Dive: EnumSet Internals\n\n### RegularEnumSet vs JumboEnumSet\n\n```java\n// EnumSet automatically chooses implementation based on enum size\n\n// RegularEnumSet: For enums with ≤64 constants\n// Uses single long (64 bits) for storage\nenum SmallEnum { A, B, C, D, E } // 5 constants → RegularEnumSet\n\n// JumboEnumSet: For enums with >64 constants\n// Uses long[] array for storage\nenum LargeEnum { /* 65+ constants */ } // → JumboEnumSet\n\n// The choice is automatic and transparent:\nEnumSet small = EnumSet.of(SmallEnum.A, SmallEnum.B); // RegularEnumSet\nEnumSet large = EnumSet.noneOf(LargeEnum.class); // JumboEnumSet\n```\n\n### RegularEnumSet Implementation\n\n```java\n// Simplified from JDK source\nclass RegularEnumSet> extends EnumSet {\n private long elements = 0L; // Bit vector\n\n public boolean add(E e) {\n long oldElements = elements;\n elements |= (1L << e.ordinal()); // Set bit\n return elements != oldElements; // Return true if changed\n }\n\n public boolean remove(Object e) {\n long oldElements = elements;\n elements &= ~(1L << ((Enum)e).ordinal()); // Clear bit\n return elements != oldElements;\n }\n\n public boolean contains(Object e) {\n return (elements & (1L << ((Enum)e).ordinal())) != 0;\n }\n\n public int size() {\n return Long.bitCount(elements); // CPU instruction!\n }\n\n public boolean isEmpty() {\n return elements == 0L;\n }\n}\n```\n\n### EnumSet Factory Methods\n\n```java\nenum Day { MON, TUE, WED, THU, FRI, SAT, SUN }\n\n// Create empty set\nEnumSet none = EnumSet.noneOf(Day.class); // {}\n\n// Create set with all values\nEnumSet all = EnumSet.allOf(Day.class); // {MON..SUN}\n\n// Create from specific values\nEnumSet workdays = EnumSet.of(Day.MON, Day.TUE, Day.WED, Day.THU, Day.FRI);\n\n// Create range (inclusive)\nEnumSet weekdays = EnumSet.range(Day.MON, Day.FRI); // {MON, TUE, WED, THU, FRI}\n\n// Create complement (all values NOT in the set)\nEnumSet weekend = EnumSet.complementOf(workdays); // {SAT, SUN}\n\n// Create from collection\nList list = Arrays.asList(Day.MON, Day.WED, Day.FRI);\nEnumSet fromList = EnumSet.copyOf(list);\n```\n\n### EnumSet vs HashSet Performance\n\n```java\n// Memory comparison\nenum Color { RED, GREEN, BLUE, YELLOW, CYAN, MAGENTA, BLACK, WHITE }\n\n// HashSet: ~200+ bytes\n// - HashSet object header\n// - HashMap backing store\n// - Entry array\n// - Entry objects for each element\n\n// EnumSet: ~24 bytes\n// - EnumSet object header\n// - Single long field (8 bytes)\n// - No additional objects!\n\n// Speed comparison (contains check)\n// HashSet: hash() → bucket lookup → equals() → ~20-50 CPU cycles\n// EnumSet: bit mask AND → ~1-3 CPU cycles\n\n// Set operations\nEnumSet a = EnumSet.of(Color.RED, Color.GREEN, Color.BLUE);\nEnumSet b = EnumSet.of(Color.GREEN, Color.BLUE, Color.YELLOW);\n\n// Union: single OR instruction\na.addAll(b); // elements |= b.elements\n\n// Intersection: single AND instruction\na.retainAll(b); // elements &= b.elements\n\n// These are O(1) operations vs O(n) for HashSet!\n```\n\n---\n\n## Deep Dive: LinkedHashSet\n\n### Predictable Iteration Order\n\n```java\n// HashSet - unpredictable order\nSet hashSet = new HashSet<>();\nhashSet.add(\"banana\");\nhashSet.add(\"apple\");\nhashSet.add(\"cherry\");\nSystem.out.println(hashSet); // Maybe: [apple, cherry, banana] or other\n\n// LinkedHashSet - insertion order preserved\nSet linkedSet = new LinkedHashSet<>();\nlinkedSet.add(\"banana\");\nlinkedSet.add(\"apple\");\nlinkedSet.add(\"cherry\");\nSystem.out.println(linkedSet); // Always: [banana, apple, cherry]\n```\n\n### LinkedHashSet Internals\n\n```java\n// LinkedHashSet extends HashSet and uses LinkedHashMap internally\n// Each entry has before/after pointers forming a doubly-linked list\n\n// Simplified structure:\nclass LinkedHashSet extends HashSet {\n // Uses LinkedHashMap as backing store\n // LinkedHashMap.Entry has: before, after pointers\n\n // Iteration follows the linked list, not buckets\n}\n\n// Visual representation:\n// HashSet buckets: LinkedHashSet linked list:\n// [0] → apple HEAD → banana → apple → cherry → TAIL\n// [1] → cherry\n// [2] → banana\n\n// Iteration:\n// HashSet: visits buckets in order → unpredictable element order\n// LinkedHashSet: follows linked list → insertion order\n```\n\n### LinkedHashSet Use Cases\n\n```java\n// Use Case 1: Deduplication while preserving order\nList withDupes = Arrays.asList(\"A\", \"B\", \"A\", \"C\", \"B\", \"D\");\nSet uniqueOrdered = new LinkedHashSet<>(withDupes);\nSystem.out.println(uniqueOrdered); // [A, B, C, D] - first occurrence order\n\n// Use Case 2: Recently used items (manual LRU)\nSet recentItems = new LinkedHashSet<>();\nrecentItems.add(\"item1\");\nrecentItems.add(\"item2\");\nrecentItems.add(\"item3\");\n// Most recent is last in iteration\n\n// Use Case 3: Configuration parsing (preserve declaration order)\nSet configKeys = new LinkedHashSet<>();\nproperties.forEach((k, v) -> configKeys.add((String) k));\n// Keys in declaration order\n\n// Use Case 4: Stable serialization/output\nSet data = new LinkedHashSet<>(inputData);\n// JSON/XML output will be consistent across runs\n```\n\n### LinkedHashSet vs TreeSet for Order\n\n```java\n// LinkedHashSet: Insertion order\n// TreeSet: Sorted order\n\nSet linked = new LinkedHashSet<>();\nlinked.add(3); linked.add(1); linked.add(2);\nSystem.out.println(linked); // [3, 1, 2] - insertion order\n\nSet tree = new TreeSet<>();\ntree.add(3); tree.add(1); tree.add(2);\nSystem.out.println(tree); // [1, 2, 3] - sorted order\n\n// Performance:\n// LinkedHashSet: O(1) add/remove/contains\n// TreeSet: O(log n) add/remove/contains\n\n// Memory:\n// LinkedHashSet: ~50% more than HashSet (linked list pointers)\n// TreeSet: ~100% more than HashSet (tree node overhead)\n```\n\n---\n\n## Deep Dive: CopyOnWriteArraySet\n\n### Thread-Safe Without Locks\n\n```java\n// CopyOnWriteArraySet is backed by CopyOnWriteArrayList\n// Write operations create a new copy of the underlying array\n// Read operations never block\n\nSet cowSet = new CopyOnWriteArraySet<>();\n\n// Thread-safe add (creates new array copy)\ncowSet.add(\"item\");\n\n// Thread-safe iteration (never throws ConcurrentModificationException)\nfor (String item : cowSet) {\n cowSet.add(\"new\"); // Safe! Iterator sees old snapshot\n}\n```\n\n### When to Use CopyOnWriteArraySet\n\n```java\n// ✅ Good use cases:\n// 1. Read-heavy, write-rare scenarios\nSet listeners = new CopyOnWriteArraySet<>();\n// Many concurrent reads (notify all), rare writes (add/remove listener)\n\n// 2. Small sets that are iterated frequently\nSet activeFeatures = new CopyOnWriteArraySet<>();\n// Feature flags checked on every request, rarely modified\n\n// 3. Sets where iteration consistency matters more than write speed\nSet observers = new CopyOnWriteArraySet<>();\n// Notification loop shouldn't miss or double-notify\n\n// ❌ Bad use cases:\n// 1. Write-heavy scenarios (too many copies)\n// 2. Large sets (copying is expensive)\n// 3. When you need fast contains() - it's O(n) not O(1)!\n```\n\n### CopyOnWriteArraySet Performance\n\n```java\n// ⚠️ Important: CopyOnWriteArraySet has O(n) contains()!\n// It uses an array internally, not a hash table\n\nCopyOnWriteArraySet cowSet = new CopyOnWriteArraySet<>();\nHashSet hashSet = new HashSet<>();\n\n// Add 10,000 elements\nfor (int i = 0; i < 10000; i++) {\n cowSet.add(\"item\" + i);\n hashSet.add(\"item\" + i);\n}\n\n// contains() performance:\n// HashSet: O(1) - ~10ns\n// CopyOnWriteArraySet: O(n) - ~50,000ns for 10K elements!\n\n// Use ConcurrentHashMap.newKeySet() if you need O(1) contains()\nSet concurrentSet = ConcurrentHashMap.newKeySet();\n```\n\n---\n\n## Deep Dive: Choosing the Right Set\n\n### Decision Matrix\n\n| Scenario | Best Choice | Why |\n|----------|-------------|-----|\n| Enum values | EnumSet | 10x faster, 10x less memory |\n| Need insertion order | LinkedHashSet | O(1) ops + order |\n| Need sorted order | TreeSet | O(log n) ops + sorted |\n| Default choice | HashSet | O(1) ops, good general |\n| Concurrent, read-heavy | CopyOnWriteArraySet | No locks on read |\n| Concurrent, write-heavy | ConcurrentHashMap.newKeySet() | Better write scaling |\n| Immutable set | Set.of() | Truly immutable |\n\n### Performance Characteristics\n\n```text\nOperation Performance (n elements):\n\n add() contains() remove() iterate\nHashSet O(1) O(1) O(1) O(n) unordered\nLinkedHash O(1) O(1) O(1) O(n) insertion order\nTreeSet O(log n) O(log n) O(log n) O(n) sorted\nEnumSet O(1)* O(1)* O(1)* O(k) enum order\nCOWArraySet O(n) O(n) O(n) O(n) snapshot\n\n* EnumSet operations are single CPU instructions, extremely fast\n```\n\n### Memory Footprint\n\n```java\n// For 1000 String elements:\n// HashSet: ~40 KB\n// LinkedHashSet: ~56 KB (+40% for links)\n// TreeSet: ~64 KB (+60% for tree nodes)\n// COWArraySet: ~8 KB (just array of references)\n\n// For 32 enum values:\n// HashSet: ~2 KB\n// EnumSet: ~32 bytes (single long!)\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Using HashSet Instead of EnumSet\n\n```java\n// ❌ WRONG: HashSet for enums\nSet permissions = new HashSet<>();\npermissions.add(Permission.READ);\npermissions.add(Permission.WRITE);\n\n// ✅ CORRECT: EnumSet for enums (always!)\nEnumSet permissions = EnumSet.of(Permission.READ, Permission.WRITE);\n\n// EnumSet is:\n// - 10x faster\n// - 10x less memory\n// - Type-safe (compile-time enum check)\n```\n\n### Mistake 2: Forgetting LinkedHashSet Order Guarantee\n\n```java\n// ❌ WRONG assumption: HashSet preserves order\nSet set = new HashSet<>();\nset.add(\"first\");\nset.add(\"second\");\nset.add(\"third\");\n// Order is NOT guaranteed!\n\n// ✅ CORRECT: Use LinkedHashSet if order matters\nSet orderedSet = new LinkedHashSet<>();\norderedSet.add(\"first\");\norderedSet.add(\"second\");\norderedSet.add(\"third\");\n// Always: [first, second, third]\n```\n\n### Mistake 3: CopyOnWriteArraySet for Large Sets\n\n```java\n// ❌ WRONG: COW for large, frequently modified sets\nSet largeSet = new CopyOnWriteArraySet<>();\nfor (int i = 0; i < 100000; i++) {\n largeSet.add(\"item\" + i); // Each add copies entire array!\n}\n// Extremely slow and memory-hungry\n\n// ✅ CORRECT: Use ConcurrentHashMap.newKeySet()\nSet largeSet = ConcurrentHashMap.newKeySet();\nfor (int i = 0; i < 100000; i++) {\n largeSet.add(\"item\" + i); // O(1) per add\n}\n```\n\n### Mistake 4: EnumSet.of() with No Arguments\n\n```java\n// ❌ WRONG: This doesn't compile\nEnumSet empty = EnumSet.of(); // Compilation error!\n\n// ✅ CORRECT: Use noneOf() for empty set\nEnumSet empty = EnumSet.noneOf(Day.class);\n\n// of() requires at least one element\nEnumSet one = EnumSet.of(Day.MON);\nEnumSet two = EnumSet.of(Day.MON, Day.TUE);\n```\n\n### Mistake 5: Modifying Set During Iteration\n\n```java\n// ❌ WRONG with HashSet/LinkedHashSet\nSet set = new LinkedHashSet<>(Arrays.asList(\"A\", \"B\", \"C\"));\nfor (String s : set) {\n if (s.equals(\"B\")) {\n set.remove(s); // 💥 ConcurrentModificationException\n }\n}\n\n// ✅ CORRECT: Use iterator.remove()\nIterator it = set.iterator();\nwhile (it.hasNext()) {\n if (it.next().equals(\"B\")) {\n it.remove();\n }\n}\n\n// ✅ CORRECT: Use removeIf()\nset.removeIf(s -> s.equals(\"B\"));\n\n// Note: CopyOnWriteArraySet allows modification during iteration\n// (but iterates over snapshot, won't see changes)\n```\n\n---\n\n## 🐛 Debug This\n\n### Challenge 1: The Disappearing Elements\n\n```java\nEnumSet workdays = EnumSet.range(Day.MON, Day.FRI);\nSet days = workdays;\n\ndays.add(Day.SAT);\nSystem.out.println(days.contains(Day.SAT));\n\ndays.clear();\ndays.addAll(Arrays.asList(Day.MON, Day.TUE, Day.WED));\nSystem.out.println(days);\n```\n\n**✅ Answer:**\n\nOutput:\n```text\ntrue\n[MON, TUE, WED]\n```\n\nThis works fine! EnumSet is mutable and supports all Set operations. The reference `days` still points to the same EnumSet.\n\n### Challenge 2: The Order Mystery\n\n```java\nSet set = new LinkedHashSet<>();\nset.add(3);\nset.add(1);\nset.add(2);\nset.remove(1);\nset.add(1);\n\nSystem.out.println(set);\n```\n\n**✅ Answer:**\n\nOutput: `[3, 2, 1]`\n\nLinkedHashSet preserves insertion order. When you remove and re-add an element, it goes to the end (new insertion position).\n\n### Challenge 3: The Concurrent Puzzle\n\n```java\nSet set = new CopyOnWriteArraySet<>(Arrays.asList(\"A\", \"B\", \"C\"));\nList collected = new ArrayList<>();\n\nfor (String s : set) {\n set.remove(s);\n collected.add(s);\n}\n\nSystem.out.println(\"Set: \" + set);\nSystem.out.println(\"Collected: \" + collected);\n```\n\n**✅ Answer:**\n\nOutput:\n```text\nSet: []\nCollected: [A, B, C]\n```\n\nCopyOnWriteArraySet iteration uses a snapshot. The iterator sees all three elements from the snapshot, while the actual set is being emptied. No ConcurrentModificationException because iterator and modifications work on different arrays.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Permission Checker\n\nCreate an efficient permission system using EnumSet:\n\n```java\npublic class PermissionChecker {\n public boolean hasAll(EnumSet userPerms, Permission... required);\n public boolean hasAny(EnumSet userPerms, Permission... required);\n public EnumSet getMissing(EnumSet userPerms, Permission... required);\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class PermissionChecker {\n\n public boolean hasAll(EnumSet userPerms, Permission... required) {\n EnumSet requiredSet = EnumSet.copyOf(Arrays.asList(required));\n return userPerms.containsAll(requiredSet);\n }\n\n public boolean hasAny(EnumSet userPerms, Permission... required) {\n for (Permission p : required) {\n if (userPerms.contains(p)) {\n return true;\n }\n }\n return false;\n }\n\n public EnumSet getMissing(EnumSet userPerms, Permission... required) {\n EnumSet requiredSet = EnumSet.copyOf(Arrays.asList(required));\n requiredSet.removeAll(userPerms);\n return requiredSet;\n }\n}\n```\n\n### Exercise 2: Ordered Deduplicator\n\nCreate a utility that deduplicates while preserving first occurrence order:\n\n```java\npublic static List deduplicatePreservingOrder(List input);\n```\n\n**✅ Solution:**\n\n```java\npublic static List deduplicatePreservingOrder(List input) {\n return new ArrayList<>(new LinkedHashSet<>(input));\n}\n\n// Example:\n// Input: [A, B, A, C, B, D, A]\n// Output: [A, B, C, D]\n```\n\n### Exercise 3: Feature Toggle System\n\nCreate a thread-safe feature toggle system:\n\n```java\npublic class FeatureToggles {\n public void enable(String feature);\n public void disable(String feature);\n public boolean isEnabled(String feature);\n public Set getAllEnabled(); // Safe snapshot\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class FeatureToggles {\n private final Set enabledFeatures = new CopyOnWriteArraySet<>();\n\n public void enable(String feature) {\n enabledFeatures.add(feature);\n }\n\n public void disable(String feature) {\n enabledFeatures.remove(feature);\n }\n\n public boolean isEnabled(String feature) {\n return enabledFeatures.contains(feature);\n }\n\n public Set getAllEnabled() {\n // COW iteration is already a snapshot, but return immutable copy\n return Set.copyOf(enabledFeatures);\n }\n}\n```\n\n### Exercise 4: EnumSet Serialization\n\nCreate utilities to serialize/deserialize EnumSet to/from a bitmask:\n\n```java\npublic class EnumSetSerializer> {\n public long toBitmask(EnumSet set);\n public EnumSet fromBitmask(Class enumClass, long bitmask);\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class EnumSetSerializer> {\n\n public long toBitmask(EnumSet set) {\n long mask = 0L;\n for (E e : set) {\n mask |= (1L << e.ordinal());\n }\n return mask;\n }\n\n public EnumSet fromBitmask(Class enumClass, long bitmask) {\n EnumSet result = EnumSet.noneOf(enumClass);\n for (E e : enumClass.getEnumConstants()) {\n if ((bitmask & (1L << e.ordinal())) != 0) {\n result.add(e);\n }\n }\n return result;\n }\n}\n\n// Usage:\nEnumSetSerializer serializer = new EnumSetSerializer<>();\nEnumSet days = EnumSet.of(Day.MON, Day.WED, Day.FRI);\nlong mask = serializer.toBitmask(days); // Store in DB as single long\nEnumSet restored = serializer.fromBitmask(Day.class, mask);\n```\n\n### Exercise 5: LRU Cache Using LinkedHashSet\n\nImplement a simple LRU (Least Recently Used) set with max capacity:\n\n```java\npublic class LRUSet extends LinkedHashSet {\n private final int maxSize;\n\n public LRUSet(int maxSize);\n // Override add to maintain max size, removing oldest if needed\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class LRUSet extends LinkedHashSet {\n private final int maxSize;\n\n public LRUSet(int maxSize) {\n super(maxSize + 1, 1.0f); // Initial capacity, load factor\n this.maxSize = maxSize;\n }\n\n @Override\n public boolean add(E e) {\n boolean added = super.add(e);\n if (size() > maxSize) {\n // Remove oldest (first in iteration order)\n Iterator it = iterator();\n it.next();\n it.remove();\n }\n return added;\n }\n\n // To make it access-ordered (move to end on access), you'd need\n // to use LinkedHashMap directly with accessOrder=true\n}\n\n// Usage:\nLRUSet recent = new LRUSet<>(3);\nrecent.add(\"A\"); // [A]\nrecent.add(\"B\"); // [A, B]\nrecent.add(\"C\"); // [A, B, C]\nrecent.add(\"D\"); // [B, C, D] - A removed as oldest\n```\n\n---\n\n## 🎤 Senior-Level Interview Questions\n\n### Question 1: EnumSet Performance\n\n**Q: Why is EnumSet faster than HashSet for enum values?**\n\n**A:**\n\nEnumSet uses bit manipulation instead of hashing:\n\n1. **Storage**: Single `long` (or `long[]`) vs HashMap with Entry objects\n2. **add/contains**: Single bit operation vs hash + equals + bucket lookup\n3. **Set operations**: Single bitwise AND/OR vs element-by-element iteration\n\n```java\n// HashSet.contains():\n// 1. Compute hash: hashCode() → ~5 ops\n// 2. Find bucket: hash % capacity → 1 op\n// 3. Compare: equals() → varies\n\n// EnumSet.contains():\n// 1. Check bit: (elements & (1L << ordinal)) != 0 → 1 op!\n```\n\n### Question 2: LinkedHashSet vs LinkedHashMap\n\n**Q: How is LinkedHashSet implemented and how does it relate to LinkedHashMap?**\n\n**A:**\n\nLinkedHashSet extends HashSet but uses LinkedHashMap as its backing store:\n\n```java\n// LinkedHashSet constructor (simplified)\npublic LinkedHashSet() {\n super(new LinkedHashMap<>()); // Uses LinkedHashMap, not HashMap!\n}\n\n// The LinkedHashMap maintains a doubly-linked list of entries\n// in insertion order, which provides the iteration order guarantee\n```\n\nKey points:\n- LinkedHashSet delegates to LinkedHashMap\n- Elements are keys in the map, value is a dummy PRESENT object\n- The linked list is through the map entries, not separate nodes\n\n### Question 3: CopyOnWriteArraySet Trade-offs\n\n**Q: What are the trade-offs of CopyOnWriteArraySet vs other concurrent set options?**\n\n**A:**\n\n| Aspect | CopyOnWriteArraySet | ConcurrentHashMap.newKeySet() |\n|--------|---------------------|-------------------------------|\n| Read performance | O(n) contains | O(1) contains |\n| Write performance | O(n) - copies array | O(1) amortized |\n| Memory on write | 2x during copy | Stable |\n| Iteration consistency | Snapshot (stale) | Weakly consistent |\n| Best for | Small, read-heavy | Large, any pattern |\n\n```java\n// CopyOnWriteArraySet: Best for listener lists\nSet listeners = new CopyOnWriteArraySet<>();\n// Few listeners, rarely modified, frequently iterated\n\n// ConcurrentHashMap.newKeySet(): Best for general concurrent use\nSet sessions = ConcurrentHashMap.newKeySet();\n// Many entries, frequent contains checks, various modifications\n```\n\n### Question 4: EnumSet.allOf() vs new HashSet(Arrays.asList())\n\n**Q: What's the difference between these two approaches for creating a set of all enum values?**\n\n**A:**\n\n```java\nenum Color { RED, GREEN, BLUE }\n\n// EnumSet.allOf() - Optimal\nEnumSet enumSet = EnumSet.allOf(Color.class);\n// Memory: ~24 bytes\n// Time: O(1) - just sets all bits to 1\n\n// HashSet approach - Wasteful\nSet hashSet = new HashSet<>(Arrays.asList(Color.values()));\n// Memory: ~300+ bytes\n// Time: O(n) - must hash and store each element\n\n// EnumSet.allOf() sets all bits in one operation:\n// elements = -1L >>> (64 - enumSize)\n```\n\n### Question 5: Ordering Guarantees\n\n**Q: Explain the iteration order guarantees of different Set implementations.**\n\n**A:**\n\n| Set Type | Iteration Order |\n|----------|----------------|\n| HashSet | Undefined (based on hash buckets) |\n| LinkedHashSet | Insertion order (first add wins) |\n| TreeSet | Sorted order (natural or Comparator) |\n| EnumSet | Declaration order (enum ordinal) |\n| CopyOnWriteArraySet | Insertion order |\n\n```java\n// HashSet: Implementation-dependent, may change on resize\n// LinkedHashSet: [first added, ..., last added]\n// TreeSet: [smallest, ..., largest]\n// EnumSet: [first declared, ..., last declared in enum]\n```\n\n### Question 6: EnumSet.copyOf() Edge Case\n\n**Q: What happens if you call EnumSet.copyOf() on an empty collection?**\n\n**A:**\n\n```java\n// Throws IllegalArgumentException!\nEnumSet set = EnumSet.copyOf(Collections.emptyList());\n// Exception: Collection is empty\n\n// Why? EnumSet.copyOf() needs to know the enum type,\n// which it infers from the first element.\n// Empty collection → no element → can't determine type.\n\n// Fix: Use noneOf() for empty sets\nEnumSet empty = EnumSet.noneOf(Day.class);\n\n// Or check first:\npublic static > EnumSet safeCopyOf(\n Collection c, Class enumClass) {\n return c.isEmpty() ? EnumSet.noneOf(enumClass) : EnumSet.copyOf(c);\n}\n```\n\n---\n\n## 📝 Summary & Key Takeaways\n\n### EnumSet\n- Always use for enum values (no exceptions!)\n- Uses bit vector: O(1) operations, minimal memory\n- RegularEnumSet (≤64 values) vs JumboEnumSet (>64)\n- Factory methods: allOf, noneOf, of, range, complementOf\n\n### LinkedHashSet\n- Preserves insertion order\n- O(1) operations like HashSet\n- ~40% memory overhead for order tracking\n- Use for ordered deduplication\n\n### CopyOnWriteArraySet\n- Thread-safe through copying\n- O(n) contains (not hash-based!)\n- Best for small, read-heavy, rarely modified sets\n- Iteration never throws ConcurrentModificationException\n\n### Decision Guidelines\n- Enums → EnumSet (always)\n- Need order → LinkedHashSet (insertion) or TreeSet (sorted)\n- Concurrent + small + read-heavy → CopyOnWriteArraySet\n- Concurrent + general → ConcurrentHashMap.newKeySet()\n- Default → HashSet\n\n---\n\n## 🏁 Conclusion\n\nSpecialized set implementations exist because one size doesn't fit all. EnumSet demonstrates how understanding your data type enables dramatic optimization - 10x performance improvement is just a class swap away.\n\nKey takeaways:\n1. **EnumSet is always better** than HashSet for enums - make it a habit\n2. **LinkedHashSet costs ~40% more memory** but provides predictable order\n3. **CopyOnWriteArraySet has O(n) contains** - don't use for large sets\n4. **Choose based on characteristics** - order, thread-safety, element type\n5. **Measure when unsure** - theoretical wins don't always materialize\n\nIn the next article, we'll explore HashMap internals deeply - the bucket array, hash distribution, and resize mechanics that power Java's most-used collection.\n\n---\n\n## 📅 Review Schedule\n\nTo solidify your understanding, review this material:\n- **Tomorrow**: Re-read EnumSet bit manipulation details\n- **In 3 days**: Implement Exercise 4 (EnumSet Serialization) again\n- **In 1 week**: Explain EnumSet vs HashSet tradeoffs to a colleague\n- **In 2 weeks**: Review the permission system production story\n\n---\n\n**Next in Series**: [Part 12: HashMap Internals - Buckets & Collisions](/articles/java-collections-part-12-hashmap-buckets-collisions)\n\n**Series Navigation**: [Part 0: How to Use This Series](/articles/java-collections-part-0-how-to-use-this-series) | [Full Index](/articles/java-collections-compendium)\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:25.965605Z","createdAt","2026-06-10T07:19:25.966333Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",17,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId",5,"seriesOrder",11,"author",{"_31":55,"_100":57,"_101":102,"_103":104,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5},"category",{"_31":62,"_73":59,"_35":91,"_76":98,"_99":-5},"tags",[79,80,81,82,83],"series",{"_31":62,"_73":74,"_35":75,"_76":77,"_78":23},"name","Java Collections Compendium: From Fundamentals to Production Mastery","java-collections-compendium","description","A comprehensive 30-part series covering everything about Java Collections Framework. From foundational concepts like generics and equals/hashCode contract, through deep dives into ArrayList, LinkedList, HashMap, TreeMap, ConcurrentHashMap, to modern features like immutable collections, Java 21 sequenced collections, streams & collectors, and production patterns with JPA, Jackson & Spring. Includes real production stories, mental models, exercises, and 50+ interview questions.","isActive",{"_31":95,"_73":96,"_35":97},{"_31":92,"_73":93,"_35":94},{"_31":90,"_73":59,"_35":91},{"_31":87,"_73":88,"_35":89},{"_31":84,"_73":85,"_35":86},338,"Set","set",344,"Linkedhashset","linkedhashset",14,"java",275,"Enumset","enumset",276,"Bit Vector","bit-vector","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]