Java 21: Sequenced Collections and the Rest of 18-21

Description

Java 21's biggest features (virtual threads, pattern matching) have their own skills. This one covers the rest: an everyday API change called sequenced collections, and the platform changes from Java 18 to 21 that affect how your code runs, from the default text encoding to the newest garbage collector.

Sequenced collections fix a long-standing annoyance. Before Java 21, "get the first and last element" meant something different for every collection:

Writing a "recently viewed" list, an LRU cache or a pagination cursor meant remembering which of these fit which type. Java 21 gives every collection that has an order the same small set of methods.

Here's the path, from easiest to most technical:

1. Sequenced collections: one vocabulary for first, last and reversed.
2. The details that surprise people.
3. The rest of Java 18 to 21: UTF-8 by default, the end of finalize, a faster garbage collector, small APIs.
4. String templates: a preview that disappeared.

Sequenced collections

Java 21 added three interfaces to the collection hierarchy:

• SequencedCollection: getFirst(), getLast(), addFirst(e), addLast(e), removeFirst(), removeLast() and reversed(). Every List, every Deque (ArrayDeque, LinkedList) and the ordered sets have them.
• SequencedSet: the same, for LinkedHashSet and sorted sets like TreeSet.
• SequencedMap: firstEntry(), lastEntry(), pollFirstEntry(), pollLastEntry(), putFirst(k, v), putLast(k, v) and reversed(), for LinkedHashMap and sorted maps like TreeMap.

List<String> list = new ArrayList<>(List.of("a", "b", "c"));
list.getFirst();        // "a"
list.getLast();         // "c"
list.reversed();        // [c, b, a]

LinkedHashMap<String, Integer> stock = new LinkedHashMap<>();
stock.put("apples", 3); stock.put("pears", 5);
stock.lastEntry();      // pears=5

HashSet and HashMap have no defined order, so they aren't sequenced: hashMap.firstEntry() doesn't compile.

The details that surprise people

getFirst() on an empty collection throws NoSuchElementException. (get(0) on an empty list throws IndexOutOfBoundsException instead.) Check isEmpty() first when the collection might be empty.

reversed() is a view, not a copy. It's a window that shows the same collection back to front, so changing it changes the original:

List<String> list = new ArrayList<>(List.of("a", "b", "c"));
list.reversed().add("z");    // adds at the END of the reversed view = the START of list
// list is now [z, a, b, c]

Looping over reversed() is free; if you need an independent reversed list, copy it: new ArrayList<>(list.reversed()).

On a LinkedHashSet, addFirst moves an element that's already there:

LinkedHashSet<String> recent = new LinkedHashSet<>(List.of("a", "b", "c"));
recent.addFirst("c");        // [c, a, b]: "c" moved to the front, no duplicate

That's a "recently used" list in a single call. LinkedHashMap.putFirst does the same for keys.

Some collections can't do some operations, and throw UnsupportedOperationException: unmodifiable lists like List.of(1, 2) can't addFirst, and a TreeSet can't either, because its order comes from sorting, not from where you insert.

The rest of Java 18 to 21

UTF-8 by default (Java 18). When code reads or writes text without naming a character encoding (new FileReader(file), new String(bytes), text.getBytes()), Java uses the default charset. That used to depend on the operating system: usually UTF-8 on Linux and macOS servers, but often windows-1252 on Windows. Since Java 18 it's UTF-8 everywhere. Files written with the old default on Windows can read differently after an upgrade. The habit that avoids all of this: always pass the charset explicitly (StandardCharsets.UTF_8) for anything that crosses systems.

finalize() is on its way out (deprecated for removal in Java 18). It runs at an unpredictable time, or never. Close resources with try-with-resources, or register cleanup with java.lang.ref.Cleaner.

Generational ZGC (Java 21). ZGC is a garbage collector that keeps pauses under a millisecond, whatever the heap size. Java 21 added a generational mode (-XX:+UseZGC -XX:+ZGenerational) that handles short-lived objects more cheaply; it became ZGC's default mode in Java 23. G1 remains the default collector.

Small but handy (Java 21): Math.clamp(value, min, max) keeps a number in range, StringBuilder.repeat(...) appends text several times, and Character.isEmoji(...) does what it says. jwebserver (Java 18) is a tiny static file server for testing.

String templates: a preview that disappeared

Java 21 previewed string templates (STR."Hello \{city}"), a way to embed expressions in strings. They stayed a preview in Java 22 and were withdrawn in Java 23 for a redesign, so code written with them on Java 21 doesn't compile on later releases. It's the clearest example of the rule from the Java 17 module: don't put preview features in code you need to keep.

Common mistakes

Check yourself

Try to answer before opening each one. Recalling beats re-reading.

1. What does list.reversed().add("z") do to list?

2. recent is a LinkedHashSet holding [a, b, c]. What is it after recent.addFirst("c")?

3. What changed about new FileReader(file) in Java 18?

4. Why does hashMap.firstEntry() not compile?

Key takeaways

• Every ordered collection now shares getFirst, getLast, addFirst, addLast, removeFirst, removeLast and reversed(); maps get firstEntry, lastEntry, putFirst and friends.
• getFirst on an empty collection throws; reversed() is a view; LinkedHashSet.addFirst moves an existing element.
• HashMap and HashSet aren't sequenced.
• UTF-8 is the default charset since Java 18, but always pass charsets explicitly.
• finalize is going away; generational ZGC arrived; string templates were withdrawn.