JDK 23: The beginning of an era of innovative features for Java development

The development of JDK 23, the upcoming standard version of Java, is progressing smoothly with two innovative features confirmed for release. Scheduled for September 19, JDK 23 has recently introduced a second preview of the class-file API. This API offers a standardized method for parsing, generating, and modifying Java class files. The class-file API was initially showcased in JDK 22, and launched on March 19. Initially planned for JDK 23 was a preview of primitive types in patterns, instanceof, and switch statements.

The primary purpose of the class-file API is to offer a standardized interface for handling class files that adhere to the format specified by the Java Virtual Machine specification with more efficiency and performance. This API aims to facilitate the transition of JDK components to this uniform API, ultimately phasing out the need for JDK's internal reliance on the third-party ASM library. Additionally, the class-file API will bring enhancements such as optimizing the CodeBuilder class. This class features various factory methods for bytecode instructions, encompassing low-level, mid-level, and high-level builders tailored for basic block operations.

In the Java development kit JDK 23, the Java development team streamlined the builder methods by eliminating redundant mid-level functions and those with limited usage. They also enhanced usability by renaming the remaining mid-level methods. Furthermore, they enhanced the ClassSignature class structure to better represent the generic signatures of superclasses and superinterfaces. As outlined in the OpenJDK proposal driving this initiative, the Java platform aims to establish and maintain a standard class-file API that evolves in tandem with the class-file format, which is slated for updates every six months.

A previously mentioned upcoming feature slated for incorporation into JDK 23 is the introduction of primitive types in patterns, instanceof, and switch statements. This enhancement aims to improve pattern matching capabilities by enabling the use of primitive type patterns across all pattern scenarios, expanding the functionality of instanceof and switch to encompass all primitive data types. Objectives of this feature encompass enabling type patterns for all data types, whether primitive or reference, supporting primitive type patterns in various contexts, and introducing user-friendly constructs to prevent data loss from unsafe type conversions. Additionally, the goals include harmonizing pattern types with instanceof, aligning instanceof with secure type casting practices, and enabling switch statements to handle values of any primitive data type.

Several features that were showcased in JDK 22 are being considered for inclusion in JDK 23. These potential additions encompass the introduction of statements before super(…) to provide developers with increased flexibility in defining constructor actions; the implementation of string templates to simplify the creation of strings containing dynamically computed values; the integration of stream gatherers to enhance the versatility and clarity of stream pipelines; the incorporation of scoped values to facilitate the sharing of unchangeable data among threads; and the proposal for implicitly declared classes and instance main methods to simplify programming for novices by reducing the need to grasp complex language features tailored for larger-scale applications.

Another potential addition to JDK 23 is a vector API designed to articulate vector calculations that efficiently compile into optimal vector instructions on compatible architectures. This vector API was in the seventh phase of development in JDK 22. Additionally, the introduction of derived record creation and a proposal for a hot code heap, aimed at enhancing application performance by decreasing execution durations, are also being considered for inclusion in JDK 23.

Oracle, the overseer of Java, has unveiled its strategic vision for Java in 2024. Oracle has detailed enhancements within various OpenJDK initiatives, including Amber for crafting concise, productivity-centric functionalities, Babylon for broadening Java's reach to diverse programming paradigms like GPUs, and Valhalla for enhancing the Java object model through the integration of value objects to address persistent performance challenges.