[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":88,"_72":89,"_35":90},"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",88,"title","Immutable Collections","slug","dsa-cheatsheet-part-17-immutable","excerpt","Visual guide to Immutable Collections: thread-safe by design. See why immutability simplifies concurrent code.","# Immutable Collections\n\n## 📋 Quick Reference\n\n| Property | Value |\n|----------|-------|\n| **Type** | Collections that cannot be modified after creation |\n| **Thread Safety** | Inherently thread-safe (no synchronization needed) |\n| **Memory** | Compact, no defensive copying needed |\n| **Null** | Not allowed in Java 9+ factory methods |\n| **Best For** | Configuration, constants, return values, multi-threading |\n\n**One-liner**: *Collections that cannot change after creation - thread-safe by design, no synchronization needed.*\n\n---\n\n## 🎮 Interactive Visualizer\n\nSee how immutable collections work and how structural sharing saves memory:\n\n```visualizer-immutable\nshowControls: true\nshowCode: true\n```\n\n**Try these operations:**\n1. See that modification throws UnsupportedOperationException\n2. Watch \"derived\" collections share structure\n3. Compare memory usage with mutable copies\n4. Observe safe sharing between threads\n\n---\n\n## 🔧 Creating Immutable Collections\n\n### Java 9+ Factory Methods (Preferred)\n\n```java\n// Immutable List\nList list = List.of(\"a\", \"b\", \"c\");\nList empty = List.of();\n\n// Immutable Set\nSet set = Set.of(\"a\", \"b\", \"c\");\nSet empty = Set.of();\n\n// Immutable Map\nMap map = Map.of(\"a\", 1, \"b\", 2);\nMap map = Map.ofEntries(\n Map.entry(\"a\", 1),\n Map.entry(\"b\", 2)\n);\n```\n\n### From Existing Collections (Java 10+)\n\n```java\n// Copy to immutable\nList immutableList = List.copyOf(existingList);\nSet immutableSet = Set.copyOf(existingSet);\nMap immutableMap = Map.copyOf(existingMap);\n\n// Collect to immutable\nList list = stream\n .collect(Collectors.toUnmodifiableList());\n\nSet set = stream\n .collect(Collectors.toUnmodifiableSet());\n\nMap map = stream\n .collect(Collectors.toUnmodifiableMap(\n keyMapper, valueMapper));\n```\n\n### Collections.unmodifiable* (View Wrapper)\n\n```java\n// ⚠️ These are VIEWS, not copies!\nList mutable = new ArrayList<>(List.of(\"a\", \"b\"));\nList unmodifiable = Collections.unmodifiableList(mutable);\n\nmutable.add(\"c\"); // This modifies the underlying list!\nunmodifiable.get(2); // Returns \"c\" - view sees changes!\n\n// ✅ For true immutability, copy first\nList safe = Collections.unmodifiableList(new ArrayList<>(mutable));\n```\n\n---\n\n## 📊 Comparison of Approaches\n\n| Method | Type | Null? | Modifications | Thread-Safe |\n|--------|------|-------|---------------|-------------|\n| `List.of()` | True copy | No | Throws | Yes |\n| `List.copyOf()` | True copy | No | Throws | Yes |\n| `unmodifiableList()` | View | Yes | View throws, source can change | If source unchanged |\n| `toUnmodifiableList()` | True copy | No | Throws | Yes |\n\n---\n\n## ✅ When to Use Immutable Collections\n\n### Good Use Cases\n\n- **Constants** - application-wide shared values\n- **Configuration** - settings that shouldn't change\n- **Method returns** - caller can't modify your internal state\n- **Multi-threading** - no synchronization needed\n- **Defensive copies** - no need to copy if immutable\n- **Map keys** - guaranteed hashCode stability\n\n### Avoid When\n\n- **Need to modify** - obvious but important\n- **Building incrementally** - use builder then convert\n- **Need null values** - Java 9+ factory methods reject null\n\n---\n\n## 🧩 Common Patterns\n\n### Configuration Constants\n\n```java\npublic class AppConfig {\n public static final List ALLOWED_ORIGINS = List.of(\n \"https://example.com\",\n \"https://api.example.com\"\n );\n\n public static final Map TIMEOUTS = Map.of(\n \"connect\", 5000,\n \"read\", 30000,\n \"write\", 10000\n );\n}\n```\n\n### Safe Return Values\n\n```java\npublic class User {\n private final Set roles;\n\n public User(Set roles) {\n // Defensive copy at construction\n this.roles = Set.copyOf(roles);\n }\n\n public Set getRoles() {\n // Safe to return - caller can't modify\n return roles;\n }\n}\n```\n\n### Builder Pattern with Immutable Result\n\n```java\npublic class Query {\n private final List fields;\n private final Map filters;\n\n private Query(Builder builder) {\n this.fields = List.copyOf(builder.fields);\n this.filters = Map.copyOf(builder.filters);\n }\n\n public static class Builder {\n private List fields = new ArrayList<>();\n private Map filters = new HashMap<>();\n\n public Builder field(String f) {\n fields.add(f);\n return this;\n }\n\n public Builder filter(String k, Object v) {\n filters.put(k, v);\n return this;\n }\n\n public Query build() {\n return new Query(this);\n }\n }\n}\n```\n\n### Thread-Safe Sharing\n\n```java\n// Immutable can be safely shared\npublic class Cache {\n private volatile Map cache = Map.of();\n\n public void updateCache(Map newData) {\n // Atomic reference swap - no synchronization needed\n this.cache = Map.copyOf(newData);\n }\n\n public Data get(String key) {\n return cache.get(key); // No lock needed\n }\n}\n```\n\n---\n\n## ⚠️ Common Pitfalls\n\n### 1. Confusing Unmodifiable with Immutable\n\n```java\n// ❌ unmodifiableList is a VIEW, not a copy\nList original = new ArrayList<>();\nList view = Collections.unmodifiableList(original);\noriginal.add(\"surprise\"); // Modifies both!\n\n// ✅ List.of() or List.copyOf() are true copies\nList immutable = List.copyOf(original);\n```\n\n### 2. Null Values\n\n```java\n// ❌ Throws NullPointerException\nList list = List.of(\"a\", null, \"b\");\n\n// ✅ Use unmodifiableList if nulls needed\nList list = Collections.unmodifiableList(\n new ArrayList<>(Arrays.asList(\"a\", null, \"b\"))\n);\n```\n\n### 3. Mutable Elements in Immutable Collection\n\n```java\n// ❌ Container is immutable, but elements can change!\nList list = List.of(new StringBuilder(\"hello\"));\nlist.get(0).append(\" world\"); // Element modified!\n\n// ✅ Use immutable elements too\nList list = List.of(\"hello\"); // Strings are immutable\n```\n\n### 4. Expecting Modification to Work\n\n```java\nList list = List.of(\"a\", \"b\");\n\n// ❌ All these throw UnsupportedOperationException\nlist.add(\"c\");\nlist.remove(0);\nlist.set(0, \"x\");\nlist.clear();\n\n// ✅ Create new collection with modification\nList newList = Stream.concat(\n list.stream(),\n Stream.of(\"c\")\n).toList();\n```\n\n---\n\n## 🔄 Immutable vs Unmodifiable vs Mutable\n\n```java\n// Mutable - can change\nList mutable = new ArrayList<>();\nmutable.add(\"a\"); // Works\n\n// Unmodifiable view - wrapper that throws on modification\n// BUT underlying collection can still change!\nList unmodifiable = Collections.unmodifiableList(mutable);\nunmodifiable.add(\"b\"); // Throws UnsupportedOperationException\nmutable.add(\"b\"); // Works! And visible through unmodifiable\n\n// Truly immutable - cannot change, period\nList immutable = List.of(\"a\", \"b\");\nimmutable.add(\"c\"); // Throws UnsupportedOperationException\n// No way to modify - there's no underlying mutable collection\n```\n\n---\n\n## 🎯 Interview Practice\n\nTest your immutable collections knowledge with 10 curated interview questions:\n\n```visualizer-immutable-interview\nshowControls: true\nshowCode: true\n```\n\n---\n\n## 🎤 Interview Tips\n\n**Q: What's the difference between immutable and unmodifiable?**\n\n> Unmodifiable is a view wrapper that prevents direct modification but the underlying collection can still change. Immutable collections truly cannot change - there's no underlying mutable collection to modify.\n\n**Q: Why use immutable collections?**\n\n> Thread safety without synchronization, no defensive copies needed, can be safely shared and cached, hashCode stability for map keys, and they communicate intent - \"this won't change\".\n\n**Q: Can I have null in List.of()?**\n\n> No, Java 9+ factory methods throw NullPointerException for null elements. This is by design - nulls in collections are often bugs. Use Collections.unmodifiableList() if you really need nulls.\n\n**Q: How do I modify an immutable collection?**\n\n> You create a new collection with the modification. Use streams or builders to derive new collections from existing ones. This is the functional programming approach.\n\n---\n\n## 📚 Series Navigation\n\n**Previous**: [Part 16: Copy-on-Write Collections](dsa-cheatsheet-part-16-copyonwrite)\n\n**Next**: [Part 18: Garbage Collection](dsa-cheatsheet-part-18-gc)\n\n---\n\n**Visualizer**: `ImmutableCollections` from `@tomaszjarosz/react-visualizers`\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:25.743023Z","createdAt","2026-06-10T07:19:25.743239Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",4,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Algorithms","readingTime","seriesId","seriesOrder",17,"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},284,"Thread-safe","thread-safe",291,"Immutable","immutable",293,"Functional","functional",292,"Collections","collections",6,"algorithms","Category for Algorithms","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]