What are Java 21 LTS features?

• LTS – Long-Term Support release, supported for years with security patches; enterprises upgrade LTS to LTS (8 to 11 to 17 to 21).
• Virtual threads (JEP 444) – lightweight, JVM-managed threads for I/O-bound concurrency, replacing the need for reactive frameworks.
• Pattern matching for switch (JEP 441) – switch cases can match types, apply guards, and the compiler enforces exhaustiveness over sealed types.
• Record patterns (JEP 440) – deconstruct records in instanceof and switch to bind components directly.
• Sequenced collections (JEP 431) – getFirst(), getLast(), addFirst(), reversed() added to ordered collection interfaces.
• Generational ZGC (JEP 439) – low-latency garbage collector with generational separation for improved throughput.

What are the major Java 21 features?

Java 21 is a landmark LTS release that consolidates several years of preview features into stable, production-ready APIs. It is the most significant Java release since Java 8.

What are virtual threads?

Virtual threads (JEP 444) are lightweight, JVM-managed threads that enable millions of concurrent threads at roughly 1 KB each. They make blocking I/O cheap by unmounting from the carrier OS thread during waits.

package com.bank.service;

import java.util.concurrent.Executors;

public class TransferService {
    public void processAll(java.util.List<String> accountIds) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (String id : accountIds) {
                executor.submit(() -> processTransfer(id));
            }
        }
    }
}

What is pattern matching for switch?

Pattern matching for switch (JEP 441) lets switch cases test types, apply guard conditions with when, and the compiler enforces exhaustiveness for sealed types.

package com.bank.model;

import java.math.BigDecimal;

sealed interface Instruction permits Buy, Sell, Transfer {}
record Buy(String symbol, int qty) implements Instruction {}
record Sell(String symbol, int qty) implements Instruction {}
record Transfer(String from, String to, BigDecimal amount) implements Instruction {}

public class InstructionProcessor {
    public String describe(Instruction instr) {
        return switch (instr) {
            case Buy b when b.qty() > 1000 -> "Large buy: " + b.symbol();
            case Buy b -> "Buy: " + b.symbol() + " x" + b.qty();
            case Sell s -> "Sell: " + s.symbol() + " x" + s.qty();
            case Transfer t -> "Transfer Rs." + t.amount() + " from " + t.from();
            // Exhaustive: compiler verifies all Instruction subtypes are covered
        };
    }
}

What are record patterns?

Record patterns (JEP 440) deconstruct records in instanceof and switch, binding components directly without calling accessor methods.

if (obj instanceof Transfer(var from, var to, var amount)) {
    System.out.println("Transfer Rs." + amount + " from " + from + " to " + to);
}

// Nested deconstruction:
record Account(String id, String holder) {}
record Payment(Account source, BigDecimal amount) {}

if (obj instanceof Payment(Account(var id, var holder), var amount)) {
    System.out.println(holder + " pays Rs." + amount + " from " + id);
}

What are sequenced collections?

Sequenced collections (JEP 431) add getFirst(), getLast(), addFirst(), addLast(), and reversed() to the SequencedCollection, SequencedSet, and SequencedMap interfaces.

import java.util.List;
import java.util.SequencedCollection;

List<String> accounts = List.of("SAV2001", "CUR3001", "FD4001");
String first = accounts.getFirst();     // "SAV2001"
String last = accounts.getLast();       // "FD4001"
List<String> reversed = accounts.reversed().stream().toList();
// ["FD4001", "CUR3001", "SAV2001"]

What is Generational ZGC?

Generational ZGC (JEP 439) adds generational collection to ZGC. Young objects (short-lived) are collected frequently and cheaply. Old objects (long-lived) are collected less often. This improves throughput while maintaining sub-millisecond pause times.

# Enable Generational ZGC
java -XX:+UseZGC -XX:+ZGenerational -jar bank-service.jar
# Pause times: < 1ms even with 100GB heap

How is Java 21 different from Java 17?

| Feature | Java 17 | Java 21 |
|---|---|---|
| Virtual threads | Not available | Final (JEP 444) |
| Pattern matching switch | Preview | Final (JEP 441) |
| Record patterns | Not available | Final (JEP 440) |
| Sequenced collections | Not available | Final (JEP 431) |
| ZGC generational | Not available | Final (JEP 439) |
| Records | Final | Final |
| Sealed classes | Final | Final |

Why do enterprises upgrade to Java 21?

Enterprises typically upgrade LTS to LTS: Java 8 to 11 to 17 to 21. Java 21 is the target because virtual threads eliminate the need for reactive frameworks (simpler code), pattern matching reduces boilerplate, and generational ZGC handles large heaps with minimal pauses. Spring Boot 3.2+ and Quarkus 3.x fully support Java 21 features.

What should a senior engineer know?

• Structured concurrency and scoped values are in preview in Java 21. They complement virtual threads for safe concurrent task management.
• String templates (STR."Hello \{name}") were previewed in Java 21 but removed in Java 23 for redesign.
• Java 21 requires module system awareness: --add-opens may be needed for libraries that use deep reflection.
• The upgrade path from Java 17 to 21 is smooth for most Spring Boot applications with minimal code changes.

What are common interview follow-up questions?

• Why is LTS important? (Enterprises need years of security patches and vendor support for production systems.)
• Can I use Java 21 features with Spring Boot? (Yes, Spring Boot 3.2+ fully supports Java 21 including virtual threads.)
• What is the next LTS after 21? (Java 25, expected September 2025.)