What's New in Java 23: A Comprehensive Overview

Java Development Kit (JDK) 23 is on the horizon, with the release candidate now available and general availability scheduled for September 17, 2024. This release brings a variety of new features and enhancements that continue to evolve the Java programming language, though it's important to note that JDK 23 is a non-LTS (Long Term Support) release, offering only six months of support from Oracle. Here's a look at the most notable additions and changes in JDK 23.

Key Features and Enhancements

1. Scoped Values (Third Preview): Scoped values, introduced in previous versions, make it easier to share immutable data within threads and with child threads. This feature is particularly beneficial when used with virtual threads and structured concurrency, reducing the overhead associated with thread-local values. In JDK 23, the ScopedValue.callWhere method sees an update, introducing a new functional interface that simplifies exception handling, while the ScopeValue.getWhere method has been removed.

2. Structured Concurrency (Third Preview): Structured concurrency aims to simplify concurrent programming by treating related tasks across multiple threads as a single unit of work. This enhancement improves error handling and observability, reducing risks like thread leaks and cancellation delays. This is the third preview of structured concurrency, continuing to build on its earlier iterations.

3. Flexible Constructor Bodies (Second Preview): This feature, previously known as "statements before super(…)," allows constructors to initialize fields before invoking a superclass constructor. This change gives developers more freedom to structure constructor logic, streamlining the process of creating classes while maintaining the top-down execution order of constructors.

4. Implicitly Declared Classes and Instance Methods: Designed to make Java more accessible for beginners, this feature allows for simpler class declarations and easier expansion of programs. JDK 23 introduces additional enhancements, including the automatic import of three static methods for text I/O and all public top-level classes and interfaces of packages exported by the java.base module.

5. Module Import Declarations (Preview): This new feature allows entire modules to be imported with a single declaration, simplifying the use of modular libraries. It aims to make Java more user-friendly for beginners and reduce the clutter of multiple import statements when using various parts of a module's API.

6. Markdown Documentation Comments: JDK 23 introduces the ability to write JavaDoc comments using Markdown, making documentation more readable and easier to write. This change should streamline the process of creating and maintaining API documentation.

7. Z Garbage Collector (ZGC) in Generational Mode: The default mode for ZGC will now be generational, focusing on more frequent collection of young objects to boost application performance. The non-generational mode will be deprecated, signaling a shift towards a more modern approach in garbage collection.

8. Vector API (Eighth Incubation): Continuing its development, the Vector API enables developers to express vector computations that compile efficiently across different CPU architectures. This incubation aims to provide a reliable, performance-oriented API for vector processing.

9. Stream Gatherers (Second Preview): This enhancement to the Stream API introduces custom intermediate operations, making stream pipelines more flexible and capable of handling infinite streams.

10. Class-File API: A new API for processing class files is being introduced, aligning with the Java Virtual Machine specification. This API is set to replace the internal ASM library, providing a more standardized approach to class file processing.

11. Primitive Types in Patterns, instanceof, and switch (Preview): This feature enhances pattern matching by allowing primitive types in pattern contexts, extending instanceof and switch statements to work with all primitive types.

Deprecated Features and Removals

• Memory Access Methods in sun.misc.Unsafe: The memory access methods in sun.misc.Unsafe are deprecated in JDK 23, with plans for their removal in a future release. Developers are encouraged to transition to the VarHandle API or the foreign function and memory API to ensure compatibility with future versions of Java.

Notable Exclusions

• String Templates: Originally previewed in JDK 21 and JDK 22, string templates have been removed from JDK 23. The feature was intended to improve Java’s string handling but has been deferred for further evaluation and potential redesign.

Final Thoughts

Java 23 continues to refine and enhance the Java platform with a focus on simplifying concurrent programming, improving performance, and making Java more accessible to new developers. While it’s a non-LTS release, the features introduced in JDK 23 set the stage for future developments in Java, making it an exciting update for the developer community. 📚💻

Java 23 is shaping up to be an essential update for developers looking to stay at the forefront of modern programming practices. Whether you’re a seasoned professional or just getting started with Java, these new features offer something for everyone.

Series Index