Java 21

The much anticipated Java Development Kit (JDK) 21 has now been made generally available. It brings with it a plethora of new features that should improve Java programming. Let's examine the main improvements and adjustments included in this edition.

1. JEP 430 - String Templates

The introduction of String Templates, a preview language feature and API suggested under JEP 430 is one of Java 21's most notable innovations. This improvement, led by Jim Laskey, attempts to improve upon Java's current text blocks and string literals. Developers may create specialized outcomes more easily by combining literal text with template processors and embedded expressions thanks to String Templates.

This feature promises better readability and easier usage of APIs taking strings from non-Java languages, while simultaneously improving the expressiveness of Java programs and offering flexibility and security.

2. JEP XYZ's Structured Concurrency

With JDK 21, Structured Concurrency takes center stage. It streamlines concurrent programming by treating groups of related activities executing in separate threads as a single unit of work via an API. Currently in preview, this feature streamlines error handling and cancellation, improving dependability and observability. Interestingly, JDK 20 and JDK 19 were used for the incubation of Structured Concurrency, and JDK 21 included a preview API for it in Java. util.concurrent package.

3. JEP XYZ - Scoped Values

Scoped Values, a new preview feature, allow immutable data to be shared across threads and inside threads. Scoped Values offer a safer alternative to method arguments for data sharing between components in big programs, addressing the drawbacks of thread-local variables. Performance, robustness, comprehensibility, and simplicity of use are given top priority in this feature, which was developed in JDK 20.

4. Key Encapsulation Mechanism API

JEP XYZ JDK 21 includes an API for Key Encapsulation Mechanisms, which provides a public cryptography-based encryption method for safeguarding symmetric keys. This improvement makes it easier to use KEM algorithms, supporting RSA-KEM and ECIES methods.

5. Windows 32-bit x86 Port Deprecation - JEP XYZ

JDK 21 suggests deprecating the Windows 32-bit x86 port to optimize system integrity and simplify processes. This port will eventually be removed in later versions. This entails upgrading the build system such that any efforts to configure a build for Windows 32-bit x86 will result in an error message. The strategy is by the October 2025 end-of-life date for Windows 10, the final version of the Windows operating system that supports 32-bit functionality.

6. nameless Classes and Instance Main Methods

To make the first learning curve in Java for students easier, JEP XYZ JDK 21 presents a preview of nameless classes and instance main methods. With the use of this feature, students may create concise declarations for programs that only require one class, adding more complex features as their proficiency grows. The plan places a strong emphasis on an easy transition to Java, reducing the formalities associated with creating basic Java programs like scripts and command-line tools.

7. JEP XYZ - Unnamed Patterns and Variables

The preview of unnamed patterns and variables that JDK 21 offers further enhances the language's versatility. Unnamed variables can be initialized but are never used, whereas unnamed patterns match record components without mentioning the name or type of the component.

8. JEP XYZ - Generational ZGC

By expanding ZGC to retain distinct generations for young and elderly items, generational ZGC is shown to be a major performance gain. This improvement allows ZGC to gather young objects more often, which lowers the likelihood of allocation delays and lowers the memory overhead and CPU overhead associated with garbage collection. When using generational ZGC instead of non-generational ZGC, applications should see improved performance without a noticeable throughput decrease.

9. Record Patterns- JEP XYZ

Record patterns are introduced in JDK 21 and build upon the prior previews in JDK 19 and 20. With the help of this capability, record values can be disassembled and record patterns and type patterns may be nested to create more modular data searches. By extending pattern matching, the proposal provides a strong, expressive, and modular method of processing and navigating data.

10. Switch Pattern Matching - JEP XYZ

After being improved upon in several JDK releases (JDK 17, JDK 18, JDK 19, and JDK 20), Pattern Matching for Switch is finally completed in JDK 21 and further improved upon in response to user input and experience. This improvement makes it possible to test switch expressions or statements against patterns, enabling the safe and efficient execution of sophisticated data-oriented searches. The inclusion of qualified enum constants in case labels and the elimination of parenthesized patterns are two notable modifications.

11. Vector API (Incubator) - JEP XYZ

JDK 21 carries on with the incubation of a vector API that expresses vector calculations that, on supported CPU architectures, compile to optimum vector instructions. Refined from JDK 16 to JDK 20, the API emphasizes dependable runtime compilation and efficiency on x64 and AArch64 platforms, as well as clean and succinct expression.

12. Third Preview of the Foreign Function and Memory API - JEP XYZ

The third preview of JDK 21's external function and memory API makes Java more compatible with code and data that aren't part of the Java runtime. By removing the brittleness linked to JNI, this API makes it easier to safely access foreign memory and efficiently invoke foreign functions.

13. Virtual Threads

JDK 21 finalizes Virtual Threads, a lightweight threading solution that was initially shown in JDK 20 and JDK 19. This feature allows for simple scaling with near-optimal hardware utilization, which should ease high-throughput concurrent applications. The constant support for thread-local variables in virtual threads in JDK 21 ensures compatibility with current libraries and facilitates the transition of task-oriented programming to virtual threads.

14. JEP XYZ Sequenced Collections

The Sequenced Collections proposal adds interfaces to represent collections with a predetermined encounter order, filling a need in the Java collections framework. The improvement specifies interfaces for sequencing collections, sets, and maps and offers consistent APIs for processing components in reverse order. The purpose of the proposal is to address the deficiency of a collection type that may represent a series of components with a specified encounter order.

15. Structured Concurrency - JEP 430

The goal of the structured concurrency programming paradigm is to make concurrent programming simpler. This paradigm is made available as a preview feature in Java 21 via JEP 430. Treating clusters of related jobs that are executed in separate threads as a single unit of work is the main objective. This method improves concurrent programming dependability and observability by simplifying error management and cancellation.

The java.util.concurrent package in Java 21 included a preview API for structured concurrency, which had been developed in JDK 20 and JDK 19. It covers typical cancellation and shutdown hazards, such delays in cancellation and thread leaks. The StructuredTaskScope::Fork(...) function in Java 21 has changed significantly; it now returns a [Subtask] instead of a Future.

Goals

Structural concurrency aims to increase the observability of concurrent code and encourage a concurrent programming style that removes cancellation and shutdown hazards.

16. Foreign Function and Memory API (Third Preview) - JEP XYZ

With code and data from outside the Java runtime, Java's interoperability is intended to be improved through the Foreign Function and Memory API. This API, which is in its third preview version for Java 21, offers secure access to external memory and fast calling of foreign functions. It seeks to eliminate the risks and brittleness related to the Java Native Interface (JNI).

Significance

The JDK 21 preview has several improvements, such as improved layout pathways, centralised native segment lifespan management, an implementation of a fallback native linker, and the elimination of the VaList. By allowing Java programmes to handle native data and access native libraries, the API broadens the range of interactions that may occur outside of the Java runtime.

Goals

The Foreign Function and Memory API aims to provide speed, safety, universality, and simplicity of use. It aims to provide a dependable substitute for JNI, enabling the call of foreign functions without jeopardizing program security.

17. Sequenced Collections - JEP XYZ

Java 21's Sequenced Collections fill a need in the collections framework by offering interfaces for representing collections with a specified encounter order. The first, second, and final items of any collection are all clearly stated. In order to process data in reverse order and accept first and last elements, uniform APIs are developed.

This proposal resolves a long-standing problem that there was no collection type in Java's collections framework to express a series of components with a specified encounter order. The challenge of not having a sequence-specific collection type is addressed by sequenced collections, which attempt to give a consistent set of operations throughout these collections.

Goals

The goals of the Sequenced Collections proposal include defining interfaces for sequencing collections, sets, and maps, retrofitting these interfaces into the existing collections type hierarchy, and providing default implementations for new methods.

18. Dynamic Loading of Agents - JEP XYZ

The capacity to load Java agents into an active Java Virtual Machine (JVM) dynamically is known as "dynamic loading of agents." Introduced by the Java Platform Profiling Architecture in JDK 5, agents are parts that may change application code while the program is executing. Agents can be dynamically loaded, enabling runtime instrumentation of classes by tools like profilers.

Java 21's dynamic loading proposal is centred on warnings that are generated when agents are dynamically loaded into an active JVM. These alerts are meant to get things ready for a release later on, when dynamic loading of agents may be prevented by default in order to increase integrity. Additionally, the proposal places a strong emphasis on syncing the dynamic loading of agents with other capabilities, obtaining application owner clearance, and bringing the Java platform closer to integrity by default.

The proposal aims to reevaluate the serviceability vs integrity trade-off, synchronise dynamic agent loading with other "superpower" features, and maintain compatibility with tools that do not need dynamic agent loading.

19. Pattern Matching for Switch (JEP XYZ)

A switch expression or statement may be evaluated against a set of patterns, each of which has a distinct action, thanks to the functionality known as Pattern Matching for Switch. JDK 17 was the starting point for this functionality, which was refined in JDK 18, JDK 19, and JDK 20 versions. It is completed in JDK 21 and has been further improved upon in light of user comments and experience.

The goal of Pattern Matching for Switch is to increase the expressiveness and utility of Java switch expressions and statements. With the help of this feature, developers may describe sophisticated data-oriented searches in a clear and safe manner by allowing patterns to appear in case labels. Additionally, it offers a means of easing a switch's past null-hostility when needed.

Goals

Expanded Expressiveness: By allowing patterns in case labels, the innovation hopes to make switch statements more adaptable and expressive.

Null-Hostility Relaxation: The historical null-hostility of switches can be eased when needed, giving additional flexibility in handling null values, by permitting patterns in switch expressions and statements.

Enhancement of Safety: By mandating that pattern switch statements cover all possible input values, the inclusion of pattern matching helps to increase the safety of switch statements.

Conclusion

To sum up, JDK 21 is evidence of Java's dedication to advancement and innovation. With these capabilities, developers may now improve the expressiveness, dependability, and speed of their Java programs. These improvements open the door to more reliable and effective program development as Java develops.