Java 21, released in September 2023, is a long-term support (LTS) version that introduces major improvements for developers and enterprises. 1. Virtual Threads are now final, enabling high-throughput concurrency with simple, synchronous-style code, drastically reducing the complexity of managing platform threads. 2. String Templates, a preview feature, offer safer and more readable string interpolation using template processors like STR, though they require --enable-preview and should not yet be used in production. 3. Pattern matching for switch is finalized, allowing cleaner, more expressive code with exhaustive type checking and seamless integration with records. 4. Sequenced Collections introduce new interfaces—SequencedCollection and SequencedMap—that standardize operations like getFirst(), getLast(), and reversed() for ordered collections. 5. Deprecated and removed features include the long-obsolete SecurityManager (marked for removal) and the fully removed Applet API, requiring migration for legacy applications. 6. Performance enhancements include generational ZGC for better memory management, continued previews of the Foreign Function & Memory API and Vector API, and improved support for ARM64 platforms. 7. Developers should upgrade from Java 17, adopt Virtual Threads in server applications, experiment cautiously with preview features, refactor concurrency code, and ensure build tools and IDEs are Java 21-compatible. Java 21 represents a transformative release that simplifies concurrency, reduces boilerplate, and improves performance, making it the new baseline for modern Java development.

Java 21, released in September 2023, is a long-term support (LTS) version—making it a major milestone for developers and enterprises alike. It brings a mix of performance improvements, new language features, and foundational changes that shape the future of Java development. If you're upgrading from Java 17 (the previous LTS), there’s a lot to embrace.

Here’s a comprehensive yet practical breakdown of what’s new and what matters most to developers.

1. Virtual Threads (Preview → Final)

One of the most transformative features in Java 21 is the finalization of Virtual Threads, which were previewed in Java 19 and 20.

What are Virtual Threads?
They are lightweight threads managed by the JVM, not the OS. Unlike traditional platform threads (which are expensive and limited in number), virtual threads allow you to spawn millions of concurrent tasks with minimal overhead.

Why it matters:

• Dramatically simplifies writing high-throughput concurrent applications (e.g., web servers, microservices).
• Reduces the need for complex async programming models (like reactive streams).
• Works seamlessly with existing java.util.concurrent APIs.

How to use it:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(1000);
            System.out.println("Task "   i   " done by "   Thread.currentThread());
            return null;
        });
    });
} // executor.close() is automatic (try-with-resources)

Key takeaway:
You can now write simple, synchronous-looking code that scales like asynchronous code. This is a game-changer for I/O-heavy workloads.

2. String Templates (Preview)

Java 21 introduces String Templates as a preview feature—aimed at making string interpolation safer and more powerful.

The problem:
Traditional string concatenation or String.format() is either verbose or error-prone:

String info = STR."User \{user.name()} is \{user.age()} years old.";

With String Templates:

String name = "Alice";
int age = 30;
String message = STR."Hello, \{name}! You are \{age} years old.";

It uses a template processor (STR) to validate and interpolate expressions at runtime. More advanced use cases can define custom processors (e.g., for SQL injection protection).

Note: This is a preview feature, so you must enable it with --enable-preview and it may evolve in future releases.

3. Pattern Matching Enhancements

Pattern matching has been evolving since Java 16. Java 21 completes the picture with pattern matching for switch expressions and statements (now final).

Before:

if (obj instanceof String s) {
    System.out.println("String: "   s.length());
} else if (obj instanceof Integer i) {
    System.out.println("Integer: "   i * 2);
}

Now (with switch):

switch (obj) {
    case String s -> System.out.println("String: "   s.length());
    case Integer i -> System.out.println("Integer: "   i * 2);
    case null, default -> System.out.println("Unknown");
}

Benefits:

• More concise and readable code.
• Exhaustiveness checking in switch expressions.
• Enables domain modeling with algebraic data types (ADTs) via records.

4. Sequenced Collections (New Interface Hierarchy)

Java 21 introduces new interfaces to better represent ordered collections:

• SequencedCollection
• SequencedMap

These unify behavior for collections with a defined encounter order (like ArrayList, LinkedHashMap, etc.).

New consistent methods:

collection.getFirst();   // instead of collection.iterator().next()
collection.getLast();    // O(1) if supported
collection.reversed();   // returns a reverse-ordered view

Example:

SequencedCollection<String> list = new ArrayList<>();
list.add("A"); list.add("B");
System.out.println(list.getLast()); // "B"
System.out.println(list.reversed()); // [B, A]

This makes working with ordered data more intuitive and consistent across implementations.

5. Deprecated and Removed Features

Java 21 continues the cleanup:

• Deprecated the SecurityManager (for removal in a future release). It’s been obsolete for years, replaced by modern security policies.
• Removal of Applet API — already deprecated in Java 9, now fully removed.

Action item:
If your app still uses Applet or SecurityManager, plan migration now. Most modern applications won’t be affected.

6. Performance, Stability, and Security Improvements

Beyond language features, Java 21 includes under-the-hood enhancements:

• Generational ZGC: The Z Garbage Collector now supports generational collection, reducing memory footprint and improving pause times for long-running apps.
• Foreign Function & Memory API (Preview): Easier, safer interaction with native code and memory (successor to JNI).
• Vector API (Preview): Enables runtime compilation of vectorized operations for high-performance computing.
• Porting improvements: Better support for macOS/AArch64 (Apple Silicon), Windows on ARM64.

These may not change your daily coding, but they future-proof your applications.

7. What Developers Should Do Now

• ? Upgrade to Java 21 if you're on Java 17 or earlier (especially for new projects).
• ? Adopt Virtual Threads in server-side applications—start with HTTP servers using Spring Boot 3.2 or Helidon.
• ?? Experiment with preview features (like String Templates) but avoid using them in production until they’re finalized.
• ? Review concurrency code: Replace thread pools with virtual threads where appropriate.
• ?? Update build tools: Ensure Maven, Gradle, and IDEs support Java 21 (most do as of late 2023).

Final Thoughts

Java 21 isn’t just about new syntax—it’s about scaling better, coding simpler, and running faster. Virtual threads alone justify the upgrade for backend developers. Combined with pattern matching, sequenced collections, and modern APIs, Java is more expressive and efficient than ever.

The language is evolving with a clear focus: reduce boilerplate, improve concurrency, and maintain backward compatibility—without sacrificing performance.

If you're building or maintaining Java applications, Java 21 is the new baseline. Start exploring, testing, and migrating.

Basically, it’s the most impactful Java release in years—don’t sleep on it.

The above is the detailed content of What's New in Java 21: A Comprehensive Developer's Guide. For more information, please follow other related articles on the PHP Chinese website!