Only 5 of Java 21’s 15 New Features Actually Change Your Code

Java 21, the next LTS after Java 17, introduces fifteen JEPs (430‑453). While many are preview or low‑impact, five features fundamentally change how code is written.

Overview of the 15 features

The release bundles features such as String Templates (JEP 430, preview), Sequenced Collections (JEP 453, preview), and various API enhancements, but only the following five are highlighted as truly transformative.

1. Virtual Threads – the "nuclear" concurrency feature

Virtual threads are lightweight JVM‑managed threads that allow millions of concurrent tasks with near‑zero context‑switch cost, eliminating the need to carefully size thread pools.

// Before: thread pool
ExecutorService pool = Executors.newFixedThreadPool(100);
for (int i = 0; i < 10000; i++) {
    pool.submit(() -> processTask(i));
}

// Java 21: one virtual thread per task
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i ->
        executor.submit(() -> processTask(i)));
}

Virtual threads make "one thread per request" the default.

2. Record Patterns – data deconstruction revolution

Java 21 revives records with pattern matching, allowing direct deconstruction in an instanceof test, including nested patterns.

// Before: verbose instanceof and cast
if (obj instanceof Point) {
    Point p = (Point) obj;
    System.out.println(p.x() + ", " + p.y());
}

// Java 21: inline deconstruction
if (obj instanceof Point(int x, int y)) {
    System.out.println(x + ", " + y);
}

// Nested deconstruction example
if (obj instanceof Person(String name, int age, Address(String city, _))) {
    System.out.println(city); // '_' ignores the rest
}

Record patterns give Java proper data deconstruction capabilities.

3. Switch Pattern Matching – ending if‑else hell

The new switch syntax supports type patterns, guard clauses, and null handling, collapsing complex conditional logic into a concise, type‑safe construct.

String formatTransaction(Object tx) {
    return switch (tx) {
        case CreditTransaction(var amount, var currency) ->
            STR."信用支付: {amount} {currency}";
        case RefundTransaction(var id, LocalDateTime time)
                when time.isAfter(LocalDate.now()) ->
            STR."异常退款: 订单{id}";
        case null -> "空交易";
        default -> "未知类型";
    };
}

Type check, variable binding, and guard clauses are all handled in a single switch.

4. String Templates – goodbye concatenation hell

String interpolation via the STR processor replaces cumbersome + concatenation, String.format, and StringBuilder usage.

String name = "Java开发者";
int unread = 42;

// Before:
String info = "用户" + user.getName() + ", 年龄" + (user.getAge() + 1) + "岁";

// Java 21:
String info = STR."用户{user.getName()}, 年龄{user.getAge() + 1}岁";

The processor supports three modes: STR – basic interpolation (e.g., STR."Hello {name}") FMT – formatted output (e.g., FMT."数值: %.2f{pi}") RAW – custom handling for full control

Java finally gets string interpolation comparable to other languages.

5. Sequenced Collections – List finally gets dignity

Lists now implement SequencedCollection, adding methods like getFirst(), reversed(), and addFirst() / addLast(). LinkedHashMap also gains firstEntry(), putLast(), and reversed() for ordered map manipulation.

SequencedCollection<String> list = new ArrayList<>();
list.addLast("End");
list.addFirst("Start");
System.out.println(list.getFirst()); // Start
System.out.println(list.reversed()); // [End, Middle, Start]

LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
map.put(1, "Java");
map.put(2, "Python");
System.out.println(map.firstEntry()); // 1=Java
map.putLast(3, "Go");
System.out.println(map.reversed()); // {3=Go, 2=Python, 1=Java}

New collection methods simplify head/tail access and ordering operations.

These five features—virtual threads, record patterns, switch pattern matching, string templates, and sequenced collections—are the ones that genuinely reshape Java programming in version 21.