[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":90,"_73":91,"_35":92},"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",119,"title","Java 21 Sequenced Collections","slug","java-collections-part-23-java21-sequenced-collections","excerpt","Modern Java 21 evolution: SequencedCollection/Set/Map for consistent first/last operations, reversed() views, and Virtual Thread implications for blocking collections.","# Java Collections Compendium Part 23: Java 21+ Sequenced Collections & Virtual Threads\n\nMaster the newest evolution in Java Collections. Learn SequencedCollection, SequencedSet, and SequencedMap interfaces that finally bring consistent first/last operations to the Collections Framework, plus how Virtual Threads change concurrent collection patterns.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| **Topic** | SequencedCollection, SequencedSet, SequencedMap, reversed(), Virtual Threads |\n| **Complexity** | Intermediate |\n| **Prerequisites** | Part 1 (Collection Framework Architecture), Part 21 (Blocking Queues) |\n| **Time to Master** | 2-3 hours |\n| **Interview Frequency** | Rising (Modern Java knowledge) |\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. Use SequencedCollection methods for first/last access\n2. Understand the new collection hierarchy with Sequenced interfaces\n3. Navigate collections in reverse with reversed() views\n4. Apply Virtual Threads patterns with blocking collections\n5. Migrate legacy code to use modern Sequenced APIs\n\n---\n\n## Production Story: The First Element Frustration\n\n### The Incident\n\nOur team maintained a data processing pipeline that needed to access first and last elements from various collection types. The code was a mess of workarounds:\n\n```java\n// DataProcessor.java - The inconsistent nightmare\npublic class DataProcessor {\n\n public void processData(Collection data) {\n // Get first element - different for every type!\n\n if (data instanceof List list) {\n Object first = list.get(0); // Works for List\n Object last = list.get(list.size() - 1);\n }\n else if (data instanceof Deque deque) {\n Object first = deque.getFirst(); // Different method!\n Object last = deque.getLast();\n }\n else if (data instanceof SortedSet sorted) {\n Object first = sorted.first(); // Yet another method!\n Object last = sorted.last();\n }\n else if (data instanceof LinkedHashSet linked) {\n // LinkedHashSet has order but NO direct first/last access!\n Iterator it = linked.iterator();\n Object first = it.next(); // Have to iterate!\n Object last = ???; // Iterate entire set?!\n }\n else {\n // Regular HashSet - no defined order at all\n throw new IllegalArgumentException(\"No order defined\");\n }\n }\n}\n```\n\n### The Problem\n\n```text\nBefore Java 21 - Inconsistent First/Last Access:\n\nCollection Type | Get First | Get Last\n---------------------|-------------------|--------------------\nArrayList | list.get(0) | list.get(size-1)\nLinkedList | list.getFirst() | list.getLast()\nArrayDeque | deque.getFirst() | deque.getLast()\nTreeSet | set.first() | set.last()\nLinkedHashSet | iterator().next() | ??? (iterate all!)\nLinkedHashMap values | ??? | ???\n\nProblems:\n├─ 6 different ways to get first element\n├─ Some collections have no direct last access\n├─ Code must check instanceof everywhere\n├─ Refactoring nightmare when collection type changes\n└─ Reversed iteration? Even more inconsistent!\n```\n\n### The Java 21 Solution\n\n```java\n// DataProcessor.java - The unified approach\npublic class DataProcessor {\n\n public void processData(SequencedCollection data) {\n // Same API for ALL sequenced collections!\n Object first = data.getFirst();\n Object last = data.getLast();\n\n // Reverse iteration - just as easy\n for (Object item : data.reversed()) {\n process(item);\n }\n }\n}\n\n// Works identically for:\nprocessData(new ArrayList<>()); // ✓\nprocessData(new LinkedList<>()); // ✓\nprocessData(new ArrayDeque<>()); // ✓\nprocessData(new TreeSet<>()); // ✓\nprocessData(new LinkedHashSet<>()); // ✓ Finally!\n```\n\n### The Difference\n\n```text\nAfter Java 21 - Unified API:\n\nSequencedCollection\n├─ getFirst() → first element\n├─ getLast() → last element\n├─ addFirst(e) → add at beginning\n├─ addLast(e) → add at end\n├─ removeFirst() → remove first\n├─ removeLast() → remove last\n└─ reversed() → reverse-order view\n\nOne interface, consistent across ALL ordered collections!\n```\n\n---\n\n## Mental Model: The Double-Ended Collection\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ SEQUENCED COLLECTIONS │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ Before Java 21: Collections with \"secret\" order │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ LinkedHashSet: \"I have order, but good luck accessing it!\" │ │\n│ │ ┌───┬───┬───┬───┬───┐ │ │\n│ │ │ A │ B │ C │ D │ E │ │ │\n│ │ └───┴───┴───┴───┴───┘ │ │\n│ │ ↑ ↑ │ │\n│ │ First? Last? │ │\n│ │ iterator() iterate all... │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ After Java 21: Collections with accessible order │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ SequencedCollection: \"First and last are first class!\" │ │\n│ │ ┌───┬───┬───┬───┬───┐ │ │\n│ │ │ A │ B │ C │ D │ E │ │ │\n│ │ └───┴───┴───┴───┴───┘ │ │\n│ │ ↑ ↑ │ │\n│ │ getFirst() getLast() │ │\n│ │ addFirst() addLast() │ │\n│ │ removeFirst() removeLast() │ │\n│ │ │ │\n│ │ reversed() → [E, D, C, B, A] (view, not copy!) │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ KEY INSIGHT: reversed() is a VIEW │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Original: [1, 2, 3, 4, 5] │ │\n│ │ ↑ ↑ │ │\n│ │ │ │ │ │\n│ │ reversed(): [5, 4, 3, 2, 1] (same data, different view) │ │\n│ │ ↑ ↑ │ │\n│ │ │ │\n│ │ Modifications to one affect the other! │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Deep Dive: The New Interface Hierarchy\n\n### SequencedCollection Interface\n\n```java\n// New interface in Java 21 - java.util.SequencedCollection\npublic interface SequencedCollection extends Collection {\n\n // ═══════════════════════════════════════════════════════════════\n // REVERSE VIEW\n // ═══════════════════════════════════════════════════════════════\n SequencedCollection reversed();\n // Returns a view in reverse order\n // Modifications reflect in both directions\n\n // ═══════════════════════════════════════════════════════════════\n // FIRST ELEMENT OPERATIONS\n // ═══════════════════════════════════════════════════════════════\n default void addFirst(E e) {\n throw new UnsupportedOperationException();\n }\n\n default E getFirst() {\n return this.iterator().next();\n }\n\n default E removeFirst() {\n var it = this.iterator();\n E e = it.next();\n it.remove();\n return e;\n }\n\n // ═══════════════════════════════════════════════════════════════\n // LAST ELEMENT OPERATIONS\n // ═══════════════════════════════════════════════════════════════\n default void addLast(E e) {\n throw new UnsupportedOperationException();\n }\n\n default E getLast() {\n return this.reversed().iterator().next();\n }\n\n default E removeLast() {\n var it = this.reversed().iterator();\n E e = it.next();\n it.remove();\n return e;\n }\n}\n```\n\n### SequencedSet Interface\n\n```java\n// For sets with defined encounter order\npublic interface SequencedSet extends Set, SequencedCollection {\n\n @Override\n SequencedSet reversed();\n // Covariant override - returns SequencedSet, not just SequencedCollection\n}\n\n// Implemented by:\n// - LinkedHashSet\n// - TreeSet (via SortedSet → NavigableSet → SequencedSet)\n// - ConcurrentSkipListSet\n```\n\n### SequencedMap Interface\n\n```java\n// For maps with defined iteration order\npublic interface SequencedMap extends Map {\n\n // ═══════════════════════════════════════════════════════════════\n // REVERSE VIEW\n // ═══════════════════════════════════════════════════════════════\n SequencedMap reversed();\n\n // ═══════════════════════════════════════════════════════════════\n // FIRST ENTRY OPERATIONS\n // ═══════════════════════════════════════════════════════════════\n default Map.Entry firstEntry() {\n var it = entrySet().iterator();\n return it.hasNext() ? new NullableKeyValueHolder<>(it.next()) : null;\n }\n\n default Map.Entry pollFirstEntry() {\n var it = entrySet().iterator();\n if (it.hasNext()) {\n var entry = new NullableKeyValueHolder<>(it.next());\n it.remove();\n return entry;\n }\n return null;\n }\n\n default V putFirst(K k, V v) {\n throw new UnsupportedOperationException();\n }\n\n // ═══════════════════════════════════════════════════════════════\n // LAST ENTRY OPERATIONS\n // ═══════════════════════════════════════════════════════════════\n default Map.Entry lastEntry() {\n var it = reversed().entrySet().iterator();\n return it.hasNext() ? new NullableKeyValueHolder<>(it.next()) : null;\n }\n\n default Map.Entry pollLastEntry() {\n var it = reversed().entrySet().iterator();\n if (it.hasNext()) {\n var entry = new NullableKeyValueHolder<>(it.next());\n it.remove();\n return entry;\n }\n return null;\n }\n\n default V putLast(K k, V v) {\n throw new UnsupportedOperationException();\n }\n\n // ═══════════════════════════════════════════════════════════════\n // SEQUENCED VIEWS\n // ═══════════════════════════════════════════════════════════════\n SequencedSet sequencedKeySet();\n SequencedCollection sequencedValues();\n SequencedSet> sequencedEntrySet();\n}\n\n// Implemented by:\n// - LinkedHashMap\n// - TreeMap (via SortedMap → NavigableMap → SequencedMap)\n// - ConcurrentSkipListMap\n```\n\n### Complete Hierarchy\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ JAVA 21 COLLECTION HIERARCHY │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ Iterable │\n│ │ │\n│ Collection │\n│ │ │\n│ ┌───────────────┼───────────────┐ │\n│ │ │ │ │\n│ List Set Queue │\n│ │ │ │ │\n│ │ SequencedSet │ │\n│ │ │ │ │ │\n│ │ SortedSet LinkedHashSet │ │\n│ │ │ │ │\n│ │ NavigableSet │ │\n│ │ │ │ │\n│ │ TreeSet Deque │\n│ │ │ │\n│ └───────────┬───────────────────┘ │\n│ │ │\n│ SequencedCollection │\n│ │\n│ Implementations: │\n│ ├─ ArrayList ────────────────────────┐ │\n│ ├─ LinkedList ───────────────────────┤ │\n│ ├─ ArrayDeque ───────────────────────┤── SequencedCollection │\n│ ├─ LinkedHashSet ────────────────────┤ │\n│ ├─ TreeSet ──────────────────────────┘ │\n│ │\n│ Map │\n│ │ │\n│ SequencedMap │\n│ │ │ │\n│ SortedMap LinkedHashMap │\n│ │ │\n│ NavigableMap │\n│ │ │\n│ TreeMap │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Deep Dive: Using Sequenced Methods\n\n### Basic Operations\n\n```java\n// Any SequencedCollection - same API everywhere\nSequencedCollection collection = new LinkedHashSet<>();\ncollection.addLast(\"A\");\ncollection.addLast(\"B\");\ncollection.addLast(\"C\");\n\n// First and last access - O(1) for most implementations\nString first = collection.getFirst(); // \"A\"\nString last = collection.getLast(); // \"C\"\n\n// Add at specific ends\ncollection.addFirst(\"Z\"); // Now: [Z, A, B, C]\ncollection.addLast(\"D\"); // Now: [Z, A, B, C, D]\n\n// Remove from ends\nString removedFirst = collection.removeFirst(); // \"Z\", now: [A, B, C, D]\nString removedLast = collection.removeLast(); // \"D\", now: [A, B, C]\n```\n\n### reversed() Views\n\n```java\n// reversed() returns a VIEW, not a copy\nList list = new ArrayList<>(List.of(1, 2, 3, 4, 5));\nSequencedCollection reversed = list.reversed();\n\nSystem.out.println(list); // [1, 2, 3, 4, 5]\nSystem.out.println(reversed); // [5, 4, 3, 2, 1]\n\n// Modifications reflect in both directions\nreversed.addFirst(6); // Add 6 at start of reversed = add at end of original\nSystem.out.println(list); // [1, 2, 3, 4, 5, 6]\nSystem.out.println(reversed); // [6, 5, 4, 3, 2, 1]\n\nlist.addFirst(0); // Add 0 at start of original\nSystem.out.println(list); // [0, 1, 2, 3, 4, 5, 6]\nSystem.out.println(reversed); // [6, 5, 4, 3, 2, 1, 0]\n\n// Reverse of reverse is original\nSystem.out.println(list == reversed.reversed()); // May not be == but equals()\n```\n\n### SequencedMap Operations\n\n```java\n// LinkedHashMap now implements SequencedMap\nSequencedMap scores = new LinkedHashMap<>();\nscores.put(\"Alice\", 100);\nscores.put(\"Bob\", 95);\nscores.put(\"Charlie\", 90);\n\n// First and last entries\nMap.Entry first = scores.firstEntry(); // Alice=100\nMap.Entry last = scores.lastEntry(); // Charlie=90\n\n// Sequenced key/value views\nSequencedSet keys = scores.sequencedKeySet();\nString firstKey = keys.getFirst(); // \"Alice\"\nString lastKey = keys.getLast(); // \"Charlie\"\n\nSequencedCollection values = scores.sequencedValues();\nInteger firstValue = values.getFirst(); // 100\nInteger lastValue = values.getLast(); // 90\n\n// putFirst/putLast for ordering control\nscores.putFirst(\"Zara\", 99); // Insert at beginning\n// Now: {Zara=99, Alice=100, Bob=95, Charlie=90}\n\nscores.putLast(\"Adam\", 88); // Insert at end\n// Now: {Zara=99, Alice=100, Bob=95, Charlie=90, Adam=88}\n\n// poll operations\nMap.Entry polled = scores.pollFirstEntry();\n// Returns Zara=99, removes it from map\n```\n\n### Iteration Patterns\n\n```java\n// Traditional forward iteration\nfor (String item : collection) {\n process(item);\n}\n\n// Reverse iteration - NOW EASY!\nfor (String item : collection.reversed()) {\n process(item);\n}\n\n// Stream in reverse\ncollection.reversed().stream()\n .filter(s -> s.length() > 3)\n .forEach(this::process);\n\n// Process from both ends\nwhile (collection.size() > 1) {\n String first = collection.removeFirst();\n String last = collection.removeLast();\n merge(first, last);\n}\n```\n\n---\n\n## Deep Dive: Virtual Threads and Collections\n\n### Virtual Threads Overview\n\n```java\n// Java 21: Virtual Threads (Project Loom)\n// Lightweight threads managed by JVM, not OS\n\n// Traditional platform thread\nThread platformThread = new Thread(() -> {\n // Runs on OS thread\n blockingOperation();\n});\n\n// Virtual thread - millions possible!\nThread virtualThread = Thread.startVirtualThread(() -> {\n // Runs on carrier thread, can be parked/unparked cheaply\n blockingOperation();\n});\n\n// Using executors\nExecutorService virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();\nvirtualExecutor.submit(() -> processWithBlocking());\n```\n\n### Virtual Threads + Blocking Collections\n\n```java\n// Before Virtual Threads: Limited by platform thread count\n// 1000 platform threads = 1000 concurrent blocking operations\n\n// With Virtual Threads: Blocking is cheap!\n// 100,000+ virtual threads, each can block on BlockingQueue\n\n// Producer-Consumer with Virtual Threads\npublic class VirtualProducerConsumer {\n private final BlockingQueue queue = new LinkedBlockingQueue<>(1000);\n\n public void start() {\n // Start many producers - each can block!\n ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();\n\n // 10,000 producers - no problem with virtual threads\n for (int i = 0; i < 10_000; i++) {\n final int id = i;\n executor.submit(() -> produce(id));\n }\n\n // 1,000 consumers\n for (int i = 0; i < 1_000; i++) {\n executor.submit(this::consume);\n }\n }\n\n private void produce(int id) {\n while (!Thread.currentThread().isInterrupted()) {\n Task task = createTask(id);\n try {\n queue.put(task); // Blocks if full - but that's OK!\n // Virtual thread parked, carrier thread free for others\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n break;\n }\n }\n }\n\n private void consume() {\n while (!Thread.currentThread().isInterrupted()) {\n try {\n Task task = queue.take(); // Blocks if empty - that's OK!\n process(task);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n break;\n }\n }\n }\n}\n```\n\n### Pattern: One-Virtual-Thread-Per-Request\n\n```java\n// Modern pattern: Simple blocking code, Virtual Thread handles concurrency\npublic class OrderService {\n private final BlockingQueue orderQueue = new ArrayBlockingQueue<>(10_000);\n\n public void processOrders() {\n try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n while (true) {\n Order order = orderQueue.take(); // Block is fine!\n\n // Each order gets its own virtual thread\n executor.submit(() -> {\n validateOrder(order); // Might block on DB\n checkInventory(order); // Might block on external service\n processPayment(order); // Might block on payment gateway\n shipOrder(order); // Might block on shipping API\n\n // All blocking - all fine with virtual threads!\n });\n }\n }\n }\n}\n```\n\n### Structured Concurrency with Collections (Preview)\n\n```java\n// Java 21+ Structured Concurrency (Preview)\n// Ensures all subtasks complete or cancel together\n\npublic List fetchAllData(List urls) throws Exception {\n try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {\n\n // Start all fetches concurrently\n List> futures = urls.stream()\n .map(url -> scope.fork(() -> fetch(url)))\n .toList();\n\n // Wait for all to complete or first failure\n scope.join();\n scope.throwIfFailed();\n\n // Collect results\n return futures.stream()\n .map(Subtask::get)\n .collect(Collectors.toList());\n }\n}\n\n// Parallel collection processing\npublic List processAll(SequencedCollection items) throws Exception {\n try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {\n\n List> tasks = new ArrayList<>();\n\n // Process in order, but concurrently\n for (Item item : items) {\n tasks.add(scope.fork(() -> process(item)));\n }\n\n scope.join();\n scope.throwIfFailed();\n\n return tasks.stream()\n .map(Subtask::get)\n .toList();\n }\n}\n```\n\n---\n\n## Deep Dive: Migration to Sequenced Collections\n\n### Before and After Comparisons\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// GETTING FIRST ELEMENT\n// ═══════════════════════════════════════════════════════════════\n\n// Before Java 21:\nString firstFromList = list.get(0);\nString firstFromDeque = deque.getFirst();\nString firstFromTreeSet = treeSet.first();\nString firstFromLinkedHashSet = linkedHashSet.iterator().next();\n\n// After Java 21:\nString first = anySequencedCollection.getFirst(); // Unified!\n\n// ═══════════════════════════════════════════════════════════════\n// GETTING LAST ELEMENT\n// ═══════════════════════════════════════════════════════════════\n\n// Before Java 21:\nString lastFromList = list.get(list.size() - 1);\nString lastFromDeque = deque.getLast();\nString lastFromTreeSet = treeSet.last();\n// LinkedHashSet last? Iterate entire set!\nString lastFromLinkedHashSet;\nfor (String s : linkedHashSet) { lastFromLinkedHashSet = s; }\n\n// After Java 21:\nString last = anySequencedCollection.getLast(); // Unified!\n\n// ═══════════════════════════════════════════════════════════════\n// REVERSE ITERATION\n// ═══════════════════════════════════════════════════════════════\n\n// Before Java 21:\n// List - use ListIterator\nListIterator it = list.listIterator(list.size());\nwhile (it.hasPrevious()) {\n process(it.previous());\n}\n\n// Deque - use descendingIterator\nfor (Iterator it = deque.descendingIterator(); it.hasNext(); ) {\n process(it.next());\n}\n\n// TreeSet - use descendingSet\nfor (String s : treeSet.descendingSet()) {\n process(s);\n}\n\n// LinkedHashSet - create new list and reverse!\nList temp = new ArrayList<>(linkedHashSet);\nCollections.reverse(temp);\nfor (String s : temp) {\n process(s);\n}\n\n// After Java 21:\nfor (String s : anySequencedCollection.reversed()) {\n process(s);\n}\n```\n\n### Migration Patterns\n\n```java\n// Pattern 1: Update method signatures\n// Before:\npublic void process(List items) {\n String first = items.get(0);\n String last = items.get(items.size() - 1);\n}\n\n// After - more flexible:\npublic void process(SequencedCollection items) {\n String first = items.getFirst();\n String last = items.getLast();\n}\n\n// Pattern 2: Replace conditional logic\n// Before:\npublic String getFirst(Collection c) {\n if (c instanceof List list) return (String) list.get(0);\n if (c instanceof Deque d) return (String) d.getFirst();\n if (c instanceof SortedSet s) return (String) s.first();\n return c.iterator().next();\n}\n\n// After:\npublic String getFirst(SequencedCollection c) {\n return c.getFirst();\n}\n\n// Pattern 3: Update stream operations for reverse\n// Before:\nList reversed = new ArrayList<>(original);\nCollections.reverse(reversed);\nreversed.stream().forEach(this::process);\n\n// After:\noriginal.reversed().stream().forEach(this::process);\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Assuming reversed() Creates a Copy\n\n```java\n// ❌ WRONG: Thinking reversed() is independent\nList original = new ArrayList<>(List.of(\"A\", \"B\", \"C\"));\nSequencedCollection reversed = original.reversed();\n\nreversed.addFirst(\"X\"); // Adds to END of original!\nSystem.out.println(original); // [A, B, C, X] - modified!\n\n// ✅ CORRECT: Understand it's a view\n// If you need independent copy:\nList reversedCopy = new ArrayList<>(original.reversed());\nreversedCopy.add(\"Y\"); // Doesn't affect original\n```\n\n### Mistake 2: Using getFirst()/getLast() on Empty Collections\n\n```java\n// ❌ WRONG: Not checking for empty\nSequencedCollection collection = new ArrayList<>();\nString first = collection.getFirst(); // NoSuchElementException!\n\n// ✅ CORRECT: Check first or use stream\nif (!collection.isEmpty()) {\n String first = collection.getFirst();\n}\n\n// Or use Optional pattern:\nOptional first = collection.stream().findFirst();\nOptional last = collection.reversed().stream().findFirst();\n```\n\n### Mistake 3: Expecting All Collections to Support addFirst/addLast\n\n```java\n// ❌ WRONG: Some collections throw UnsupportedOperationException\nSequencedSet set = new TreeSet<>(List.of(\"B\", \"C\"));\nset.addFirst(\"A\"); // UnsupportedOperationException!\n// TreeSet order is determined by comparison, not insertion\n\n// ✅ CORRECT: Check collection type or use supported collections\nSequencedSet linked = new LinkedHashSet<>();\nlinked.addFirst(\"A\"); // OK - LinkedHashSet supports this\n\n// For TreeSet, just add and let sorting handle position:\nTreeSet tree = new TreeSet<>();\ntree.add(\"A\"); // Will be positioned by natural order\n```\n\n### Mistake 4: Confusing pollFirst with removeFirst\n\n```java\n// ❌ CONFUSING: Different behavior on empty collection\nSequencedCollection empty = new LinkedHashSet<>();\n\nempty.removeFirst(); // NoSuchElementException!\n// vs\n// empty.pollFirst(); // Returns null (if method existed)\n\n// Note: SequencedCollection doesn't have poll methods\n// Use Deque or NavigableSet if you need null-returning removal\n\n// ✅ CORRECT: Use appropriate type\nDeque deque = new ArrayDeque<>();\nString polled = deque.pollFirst(); // null, no exception\n\nNavigableSet navSet = new TreeSet<>();\nString polled2 = navSet.pollFirst(); // null, no exception\n```\n\n### Mistake 5: Ignoring Thread Safety with Virtual Threads\n\n```java\n// ❌ WRONG: Non-thread-safe collection with Virtual Threads\nList results = new ArrayList<>();\n\ntry (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n for (Task task : tasks) {\n executor.submit(() -> {\n Result r = process(task);\n results.add(r); // Race condition!\n });\n }\n}\n\n// ✅ CORRECT: Use thread-safe collection or collect properly\nList results = Collections.synchronizedList(new ArrayList<>());\n// or\nCopyOnWriteArrayList results = new CopyOnWriteArrayList<>();\n// or better - use Structured Concurrency to collect results\n```\n\n---\n\n## 🐛 Debug This\n\n### Challenge 1: The Disappearing Elements\n\n```java\nLinkedHashSet set = new LinkedHashSet<>(List.of(\"A\", \"B\", \"C\"));\nSequencedSet reversed = set.reversed();\n\nfor (String s : reversed) {\n if (s.equals(\"B\")) {\n set.remove(s); // What happens?\n }\n}\n```\n\n**✅ Answer:**\n\n`ConcurrentModificationException`! Even though you're removing from `set`, you're iterating over `reversed` which is a view of the same set.\n\n**Fix:**\n```java\n// Option 1: Collect to remove, then remove\nList toRemove = new ArrayList<>();\nfor (String s : reversed) {\n if (s.equals(\"B\")) toRemove.add(s);\n}\ntoRemove.forEach(set::remove);\n\n// Option 2: Use removeIf\nset.removeIf(s -> s.equals(\"B\"));\n\n// Option 3: Use iterator's remove\nvar it = reversed.iterator();\nwhile (it.hasNext()) {\n if (it.next().equals(\"B\")) it.remove();\n}\n```\n\n### Challenge 2: The Stubborn TreeSet\n\n```java\nSequencedSet tree = new TreeSet<>(List.of(3, 1, 2));\ntree.addFirst(0); // What happens?\n```\n\n**✅ Answer:**\n\n`UnsupportedOperationException`! TreeSet doesn't support positional insertion because element position is determined by comparison, not insertion order.\n\n**Fix:**\n```java\n// For TreeSet, just add - position determined by ordering\ntree.add(0); // Will be first because 0 < 1 < 2 < 3\n\n// If you need insertion-order control, use LinkedHashSet\nSequencedSet linked = new LinkedHashSet<>();\nlinked.addFirst(0); // OK\n```\n\n### Challenge 3: The Virtual Thread Deadlock\n\n```java\nBlockingQueue queue1 = new ArrayBlockingQueue<>(1);\nBlockingQueue queue2 = new ArrayBlockingQueue<>(1);\n\ntry (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n executor.submit(() -> {\n queue1.put(1); // Put succeeds\n queue2.take(); // Blocks waiting for queue2\n });\n\n executor.submit(() -> {\n queue2.put(2); // Put succeeds\n queue1.take(); // Blocks waiting for queue1\n });\n}\n// What happens?\n```\n\n**✅ Answer:**\n\nDeadlock! Both threads are blocked:\n- Thread 1: waiting on queue2.take()\n- Thread 2: waiting on queue1.take()\n\nNeither can proceed because neither has taken from the queue the other is waiting to take from.\n\n**Fix:**\n```java\n// Use consistent ordering or timeout\nexecutor.submit(() -> {\n queue1.put(1);\n if (!queue2.poll(1, TimeUnit.SECONDS)) {\n // Handle timeout\n }\n});\n\n// Or redesign the communication pattern\nBlockingQueue shared = new ArrayBlockingQueue<>(10);\n// One producer, one consumer, single queue\n```\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Sequenced Collection Utilities\n\nCreate utility methods that work with any SequencedCollection:\n\n```java\npublic class SequencedUtils {\n public static E middle(SequencedCollection c); // Get middle element\n public static List firstN(SequencedCollection c, int n);\n public static List lastN(SequencedCollection c, int n);\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class SequencedUtils {\n\n public static E middle(SequencedCollection c) {\n if (c.isEmpty()) {\n throw new NoSuchElementException(\"Collection is empty\");\n }\n int middleIndex = c.size() / 2;\n Iterator it = c.iterator();\n for (int i = 0; i < middleIndex; i++) {\n it.next();\n }\n return it.next();\n }\n\n public static List firstN(SequencedCollection c, int n) {\n if (n < 0) throw new IllegalArgumentException(\"n must be non-negative\");\n return c.stream()\n .limit(n)\n .toList();\n }\n\n public static List lastN(SequencedCollection c, int n) {\n if (n < 0) throw new IllegalArgumentException(\"n must be non-negative\");\n return c.reversed().stream()\n .limit(n)\n .collect(Collectors.collectingAndThen(\n Collectors.toList(),\n list -> { Collections.reverse(list); return list; }\n ));\n }\n\n // Bonus: Take from both ends alternately\n public static List interleaveEnds(SequencedCollection c) {\n List result = new ArrayList<>();\n var forward = c.iterator();\n var backward = c.reversed().iterator();\n int count = c.size();\n\n for (int i = 0; i < count; i++) {\n if (i % 2 == 0 && forward.hasNext()) {\n result.add(forward.next());\n } else if (backward.hasNext()) {\n result.add(backward.next());\n }\n }\n return result;\n }\n}\n```\n\n### Exercise 2: LRU Cache with SequencedMap\n\nImplement an LRU cache using SequencedMap:\n\n```java\npublic class LRUCache {\n public LRUCache(int maxSize);\n public V get(K key);\n public void put(K key, V value);\n public int size();\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class LRUCache {\n private final int maxSize;\n private final SequencedMap cache = new LinkedHashMap<>();\n\n public LRUCache(int maxSize) {\n if (maxSize <= 0) throw new IllegalArgumentException(\"maxSize must be positive\");\n this.maxSize = maxSize;\n }\n\n public synchronized V get(K key) {\n V value = cache.remove(key); // Remove from current position\n if (value != null) {\n cache.putLast(key, value); // Add to end (most recently used)\n }\n return value;\n }\n\n public synchronized void put(K key, V value) {\n cache.remove(key); // Remove if exists\n\n if (cache.size() >= maxSize) {\n cache.pollFirstEntry(); // Remove least recently used\n }\n\n cache.putLast(key, value); // Add to end\n }\n\n public synchronized int size() {\n return cache.size();\n }\n\n // Bonus: Get all entries in LRU order (oldest first)\n public synchronized List> entriesLRUOrder() {\n return new ArrayList<>(cache.sequencedEntrySet());\n }\n\n // Bonus: Get all entries in MRU order (newest first)\n public synchronized List> entriesMRUOrder() {\n return new ArrayList<>(cache.reversed().sequencedEntrySet());\n }\n}\n```\n\n### Exercise 3: Parallel Batch Processor with Virtual Threads\n\nCreate a batch processor that uses Virtual Threads:\n\n```java\npublic class ParallelBatchProcessor {\n public ParallelBatchProcessor(Function processor, int batchSize);\n public List processAll(SequencedCollection items);\n // Process in parallel but maintain order in results\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class ParallelBatchProcessor {\n private final Function processor;\n private final int batchSize;\n\n public ParallelBatchProcessor(Function processor, int batchSize) {\n this.processor = processor;\n this.batchSize = batchSize;\n }\n\n public List processAll(SequencedCollection items) {\n List itemList = new ArrayList<>(items);\n List results = new ArrayList<>(Collections.nCopies(itemList.size(), null));\n\n try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n List> futures = new ArrayList<>();\n\n // Process in batches\n for (int i = 0; i < itemList.size(); i += batchSize) {\n final int start = i;\n final int end = Math.min(i + batchSize, itemList.size());\n\n futures.add(executor.submit(() -> {\n for (int j = start; j < end; j++) {\n R result = processor.apply(itemList.get(j));\n results.set(j, result); // Position preserved!\n }\n }));\n }\n\n // Wait for all batches\n for (Future future : futures) {\n future.get();\n }\n } catch (Exception e) {\n throw new RuntimeException(\"Processing failed\", e);\n }\n\n return results;\n }\n\n // Alternative using Structured Concurrency (Preview)\n public List processAllStructured(SequencedCollection items) throws Exception {\n try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {\n List> tasks = new ArrayList<>();\n\n for (T item : items) {\n tasks.add(scope.fork(() -> processor.apply(item)));\n }\n\n scope.join();\n scope.throwIfFailed();\n\n return tasks.stream()\n .map(Subtask::get)\n .toList();\n }\n }\n}\n```\n\n---\n\n## 🎤 Senior-Level Interview Questions\n\n### Question 1: Sequenced Collection Motivation\n\n**Q: Why were SequencedCollection interfaces added in Java 21? What problem do they solve?**\n\n**A:**\n\nBefore Java 21, ordered collections had inconsistent APIs:\n\n```java\n// Getting first element - 4 different ways:\nlist.get(0) // List\ndeque.getFirst() // Deque\nsortedSet.first() // SortedSet\nset.iterator().next() // LinkedHashSet - no direct method!\n\n// Getting last element - even worse:\nlist.get(list.size()-1) // List\ndeque.getLast() // Deque\nsortedSet.last() // SortedSet\n// LinkedHashSet - iterate entire set!\n```\n\nSequencedCollection provides:\n1. **Unified API**: Same methods across all ordered collections\n2. **Direct last access**: LinkedHashSet finally has getLast()\n3. **Reverse views**: reversed() works everywhere\n4. **Type safety**: Compiler knows a collection has order\n\n### Question 2: reversed() View Semantics\n\n**Q: Is reversed() a copy or a view? What are the implications?**\n\n**A:**\n\nIt's a **view**, not a copy:\n\n```java\nList list = new ArrayList<>(List.of(1, 2, 3));\nSequencedCollection rev = list.reversed();\n\n// Modifications affect both:\nrev.addFirst(4); // Adds to END of original list\nSystem.out.println(list); // [1, 2, 3, 4]\nSystem.out.println(rev); // [4, 3, 2, 1]\n\nlist.add(5);\nSystem.out.println(rev); // [5, 4, 3, 2, 1]\n```\n\nImplications:\n- Memory efficient (no copy)\n- Changes propagate both directions\n- Iteration can throw ConcurrentModificationException if original modified\n- Need explicit copy if independence required: `new ArrayList<>(c.reversed())`\n\n### Question 3: Virtual Threads Impact\n\n**Q: How do Virtual Threads change the patterns for using blocking collections?**\n\n**A:**\n\nWith platform threads, blocking was expensive:\n- Each blocked thread = OS thread blocked\n- Limited to ~10K platform threads\n- Had to use non-blocking patterns, async, reactive\n\nWith Virtual Threads, blocking is cheap:\n- Blocked virtual thread = carrier thread released\n- Millions of virtual threads possible\n- Simple blocking code scales\n\n```java\n// Old pattern: Non-blocking to avoid thread exhaustion\nCompletableFuture.supplyAsync(() -> queue.poll())\n .thenAccept(this::process);\n\n// New pattern: Simple blocking code\nexecutor.submit(() -> {\n Item item = queue.take(); // Blocks - but that's fine!\n process(item);\n});\n\n// Can have thousands of tasks blocked on queue.take()\n// Carrier threads automatically reassigned to runnable tasks\n```\n\n### Question 4: Migration Strategy\n\n**Q: How would you migrate a codebase to use Sequenced Collections?**\n\n**A:**\n\nGradual migration strategy:\n\n1. **Update method parameters** (broadest impact):\n```java\n// Before:\npublic void process(List items)\n\n// After - accepts more types:\npublic void process(SequencedCollection items)\n```\n\n2. **Replace workarounds**:\n```java\n// Before:\nString last = list.get(list.size() - 1);\n// After:\nString last = list.getLast();\n```\n\n3. **Simplify reverse iteration**:\n```java\n// Before:\nListIterator it = list.listIterator(list.size());\nwhile (it.hasPrevious()) { ... }\n\n// After:\nfor (T item : list.reversed()) { ... }\n```\n\n4. **Clean up instanceof checks**:\n```java\n// Before: Type-specific handling\n// After: Single SequencedCollection path\n```\n\n### Question 5: TreeSet and addFirst\n\n**Q: Why does TreeSet throw UnsupportedOperationException on addFirst()?**\n\n**A:**\n\nTreeSet is ordered by **comparison**, not **insertion order**:\n\n```java\nTreeSet set = new TreeSet<>();\nset.add(3); // Position determined by value\nset.add(1); // Becomes first because 1 < 3\nset.add(2); // Becomes second because 1 < 2 < 3\n\n// addFirst(0) would mean \"insert 0 at beginning\"\n// But TreeSet would put it first anyway because 0 < 1\n// The \"first\" semantic conflicts with sort order\n\n// So TreeSet throws UnsupportedOperationException for:\nset.addFirst(x); // ❌\nset.addLast(x); // ❌\n\n// But supports reading first/last:\nset.getFirst(); // ✓ Returns smallest\nset.getLast(); // ✓ Returns largest\n```\n\n---\n\n## 📝 Summary & Key Takeaways\n\n### New Interfaces\n\n| Interface | Key Methods | Implementations |\n|-----------|-------------|-----------------|\n| `SequencedCollection` | getFirst/Last, addFirst/Last, removeFirst/Last, reversed() | ArrayList, LinkedList, ArrayDeque, LinkedHashSet, TreeSet |\n| `SequencedSet` | (extends Set + SequencedCollection) | LinkedHashSet, TreeSet, ConcurrentSkipListSet |\n| `SequencedMap` | firstEntry, lastEntry, putFirst/Last, pollFirst/Last | LinkedHashMap, TreeMap, ConcurrentSkipListMap |\n\n### Key Points\n\n1. **reversed() is a view** - modifications affect both directions\n2. **Not all methods supported everywhere** - TreeSet doesn't support addFirst/Last\n3. **Virtual Threads enable simple blocking patterns** - embrace queue.take()\n4. **Migration is gradual** - update parameters to accept SequencedCollection\n\n### Virtual Threads Summary\n\n- Blocking collections now practical at scale\n- Simple code replaces complex async patterns\n- Structured Concurrency for coordinated tasks\n- Still need thread-safe collections for shared state\n\n---\n\n## 🏁 Conclusion\n\nJava 21's Sequenced Collections and Virtual Threads represent a major evolution in Java development. Sequenced Collections finally unify the inconsistent APIs for ordered collections, while Virtual Threads make simple blocking code scalable again.\n\nKey takeaways:\n1. **Use SequencedCollection in method signatures** for flexibility\n2. **Understand reversed() is a view** not a copy\n3. **Virtual Threads make blocking cheap** - write simple code\n4. **Structured Concurrency for coordinated parallel work**\n5. **Gradual migration is safe** - new interfaces extend existing ones\n\nIn the next article, we'll explore Streams and Collectors - powerful tools for transforming and aggregating collections that work beautifully with both traditional and sequenced collections.\n\n---\n\n## 📅 Review Schedule\n\nTo solidify your understanding, review this material:\n- **Tomorrow**: Practice getFirst()/getLast() with different collection types\n- **In 3 days**: Implement something using reversed() views\n- **In 1 week**: Try Virtual Threads with BlockingQueue\n- **In 2 weeks**: Review migration patterns for existing code\n\n---\n\n**Next in Series**: [Part 24: Streams & Collectors](/articles/java-collections-part-24-streams-collectors)\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:26.141566Z","createdAt","2026-06-10T07:19:26.142359Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",21,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId",5,"seriesOrder",23,"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":97,"_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":96,"_73":59,"_35":97},{"_31":93,"_73":94,"_35":95},{"_31":90,"_73":91,"_35":92},{"_31":87,"_73":88,"_35":89},{"_31":84,"_73":85,"_35":86},366,"Sequencedset","sequencedset",367,"Sequencedmap","sequencedmap",365,"Sequencedcollection","sequencedcollection",104,"Java 21","java-21",14,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]