[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":82,"_72":83,"_35":84},"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":52,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71},"id",79,"title","EnumSet / Bit Vector","slug","dsa-cheatsheet-part-8-enumset","excerpt","Visual guide to EnumSet: bit vector representation for enum values. See ultra-fast set operations on bits.","# EnumSet\n\n## 📋 Quick Reference\n\n| Property | Value |\n|----------|-------|\n| **Type** | Bit vector for enum constants |\n| **Add/Remove/Contains** | O(1) - single bit operation |\n| **Iteration** | O(n) where n = enum size, not set size |\n| **Memory** | One bit per enum constant (extremely compact) |\n| **Null** | Not allowed |\n| **Best For** | Sets of enum values, flags, permissions |\n\n**One-liner**: *Ultra-efficient bit vector set for enum types - O(1) operations with minimal memory.*\n\n---\n\n## 🎮 Interactive Visualizer\n\nWatch how EnumSet uses bits to represent set membership:\n\n```visualizer-enumset\nshowControls: true\nshowCode: true\n```\n\n**Try these operations:**\n1. Add elements - see bits flip to 1\n2. Remove elements - see bits flip to 0\n3. Union/intersection - observe bitwise operations\n4. Notice: each enum constant is just one bit!\n\n---\n\n## 🔧 Key Operations\n\n### Creating\n\n```java\nenum Day { MON, TUE, WED, THU, FRI, SAT, SUN }\n\n// Empty set\nEnumSet empty = EnumSet.noneOf(Day.class);\n\n// All values\nEnumSet all = EnumSet.allOf(Day.class);\n\n// Specific values\nEnumSet weekend = EnumSet.of(Day.SAT, Day.SUN);\nEnumSet weekdays = EnumSet.range(Day.MON, Day.FRI);\n\n// Complement (all except specified)\nEnumSet notWeekend = EnumSet.complementOf(weekend);\n\n// Copy\nEnumSet copy = EnumSet.copyOf(existingSet);\n```\n\n### Adding/Removing\n\n```java\nset.add(Day.MON); // O(1) - set bit\nset.addAll(EnumSet.of(Day.TUE, Day.WED)); // O(1) - OR bits\n\nset.remove(Day.MON); // O(1) - clear bit\nset.removeAll(weekend); // O(1) - AND with complement\nset.retainAll(weekdays); // O(1) - AND bits\n\nset.clear(); // O(1) - zero all bits\n```\n\n### Querying\n\n```java\nboolean has = set.contains(Day.MON); // O(1) - check bit\nboolean hasAll = set.containsAll(weekend); // O(1) - AND compare\nboolean empty = set.isEmpty(); // O(1) - check if zero\nint size = set.size(); // O(1) - popcount\n```\n\n### Iteration\n\n```java\n// Natural enum order (declaration order)\nfor (Day day : set) {\n // Days in declaration order, not insertion order\n}\n\n// With stream\nset.stream()\n .filter(d -> d.ordinal() < 5)\n .forEach(System.out::println);\n```\n\n---\n\n## 📊 Complexity Analysis\n\n| Operation | Time | Notes |\n|-----------|------|-------|\n| `add(e)` | O(1) | Single bit set |\n| `remove(e)` | O(1) | Single bit clear |\n| `contains(e)` | O(1) | Single bit check |\n| `addAll/removeAll` | O(1) | Bitwise OR/AND |\n| `size()` | O(1) | Popcount (bit counting) |\n| `iteration` | O(n) | n = total enum constants |\n| `equals` | O(1) | Compare bit vectors |\n\n### Bit Vector Representation\n\n```\nenum Permission { READ, WRITE, EXECUTE, DELETE }\n\nBit positions: DELETE EXECUTE WRITE READ\n 3 2 1 0\n\nEnumSet.of(READ, WRITE) = 0011 (binary) = 3\nEnumSet.of(READ, EXECUTE) = 0101 (binary) = 5\nEnumSet.allOf() = 1111 (binary) = 15\nEnumSet.noneOf() = 0000 (binary) = 0\n\nOperations:\nadd(EXECUTE): 0011 | 0100 = 0111\nremove(READ): 0111 & 1110 = 0110\ncontains(WRITE): 0110 & 0010 = 0010 (truthy)\n```\n\n### Internal Implementation\n\n```java\n// For enums with ≤64 constants:\nRegularEnumSet uses: long elements; // 64 bits\n\n// For enums with >64 constants:\nJumboEnumSet uses: long[] elements; // Array of longs\n```\n\n---\n\n## ✅ When to Use EnumSet\n\n### Good Use Cases\n\n- **Permission/role flags** - user permissions, feature flags\n- **State combinations** - multiple states at once\n- **Day/month subsets** - working days, quarter months\n- **Configuration options** - enabled features\n- **Replacing bit flags** - type-safe alternative to int flags\n\n### Avoid When\n\n- **Non-enum types** - use HashSet instead\n- **Need insertion order** - EnumSet uses declaration order\n- **Need null elements** - EnumSet prohibits null\n- **Dynamic values** - enums are compile-time fixed\n\n---\n\n## 🧩 Common Patterns\n\n### Permissions System\n\n```java\nenum Permission { READ, WRITE, EXECUTE, DELETE, ADMIN }\n\npublic class User {\n private EnumSet permissions = EnumSet.noneOf(Permission.class);\n\n public void grant(Permission... perms) {\n permissions.addAll(EnumSet.copyOf(Arrays.asList(perms)));\n }\n\n public void revoke(Permission perm) {\n permissions.remove(perm);\n }\n\n public boolean can(Permission perm) {\n return permissions.contains(perm);\n }\n\n public boolean canAll(EnumSet required) {\n return permissions.containsAll(required);\n }\n}\n\n// Usage\nUser user = new User();\nuser.grant(Permission.READ, Permission.WRITE);\nuser.can(Permission.READ); // true\nuser.can(Permission.ADMIN); // false\n```\n\n### Feature Flags\n\n```java\nenum Feature { DARK_MODE, NOTIFICATIONS, BETA_FEATURES, ANALYTICS }\n\nEnumSet enabledFeatures = EnumSet.of(Feature.DARK_MODE);\n\nif (enabledFeatures.contains(Feature.BETA_FEATURES)) {\n showBetaUI();\n}\n```\n\n### Replacing Bit Flags\n\n```java\n// ❌ Old-style bit flags (error-prone)\npublic static final int FLAG_READ = 1;\npublic static final int FLAG_WRITE = 2;\npublic static final int FLAG_EXECUTE = 4;\nint permissions = FLAG_READ | FLAG_WRITE;\n\n// ✅ Type-safe EnumSet\nenum Permission { READ, WRITE, EXECUTE }\nEnumSet permissions = EnumSet.of(Permission.READ, Permission.WRITE);\n```\n\n---\n\n## ⚠️ Common Pitfalls\n\n### 1. Using HashSet Instead of EnumSet\n\n```java\n// ❌ HashSet for enums - slower, more memory\nSet days = new HashSet<>();\n\n// ✅ EnumSet - optimized for enums\nSet days = EnumSet.noneOf(Day.class);\n```\n\n### 2. Forgetting Declaration Order\n\n```java\nenum Priority { LOW, MEDIUM, HIGH }\n\nEnumSet set = EnumSet.of(Priority.HIGH, Priority.LOW);\nfor (Priority p : set) {\n System.out.println(p); // Prints: LOW, HIGH (declaration order!)\n}\n```\n\n### 3. Creating from Empty Collection\n\n```java\n// ❌ Throws IllegalArgumentException\nEnumSet set = EnumSet.copyOf(Collections.emptyList());\n\n// ✅ Use noneOf for empty sets\nEnumSet set = EnumSet.noneOf(Day.class);\n```\n\n### 4. Expecting Null Support\n\n```java\n// ❌ Throws NullPointerException\nset.add(null);\n\n// EnumSet does not allow null - by design\n// Use a special NONE enum constant if needed\nenum Status { NONE, ACTIVE, INACTIVE }\n```\n\n---\n\n## 🎤 Interview Tips\n\n**Q: Why is EnumSet so fast?**\n\n> It represents the set as a bit vector (typically a single long). Each enum constant maps to a bit position. add/remove/contains are single bit operations - literally O(1) with tiny constant factors.\n\n**Q: How much memory does EnumSet use?**\n\n> For enums with ≤64 constants: 8 bytes (one long) plus object overhead. For larger enums: ceil(n/64) longs. Compare to HashSet which uses ~32 bytes per element.\n\n**Q: EnumSet vs EnumMap?**\n\n> EnumSet is a Set of enum values (no associated values). EnumMap is a Map with enum keys and any values. Both use array indexing by ordinal for efficiency.\n\n**Q: Can EnumSet work with any enum?**\n\n> Yes, any enum type. The type parameter ensures type safety. Implementation automatically chooses RegularEnumSet (≤64 constants) or JumboEnumSet (>64 constants).\n\n---\n\n## 📚 Series Navigation\n\n**Previous**: [Part 7: LinkedHashMap](dsa-cheatsheet-part-7-linkedhashmap)\n\n**Next**: [Part 9: Binary Search](dsa-cheatsheet-part-9-binary-search)\n\n---\n\n**Visualizer**: `EnumSet` from `@tomaszjarosz/react-visualizers`\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:25.663551Z","createdAt","2026-06-10T07:19:25.663773Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",4,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Algorithms","readingTime","seriesId","seriesOrder",8,"author",{"_31":55,"_98":57,"_99":100,"_101":102,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5},"category",{"_31":94,"_72":59,"_35":95,"_75":96,"_97":-5},"tags",[78,79,80,81],"series",{"_31":52,"_72":73,"_35":74,"_75":76,"_77":23},"name","Interactive Data Structures & Algorithms","dsa-visualized-cheatsheet","description","A concise, visual reference for essential data structures and algorithms. Each article features an interactive visualizer showing how the structure/algorithm works step-by-step, along with complexity analysis, use cases, and quick reference code. Perfect for interview prep, quick review, or learning by visualization.","isActive",{"_31":91,"_72":92,"_35":93},{"_31":88,"_72":89,"_35":90},{"_31":85,"_72":86,"_35":87},{"_31":82,"_72":83,"_35":84},277,"Memory Efficient","memory-efficient",275,"Enumset","enumset",252,"Data Structure","data-structure",276,"Bit Vector","bit-vector",6,"algorithms","Category for Algorithms","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]