What’s New in Java 22? 12 Feature Enhancements Explained

On the evening before, Java 22 was officially released, bringing twelve feature enhancements, including seven preview features and one incubator feature, covering improvements to the language, APIs, performance, and tools.

Unnamed Variables & Patterns

JEP 456 introduces unnamed variables and patterns, using the underscore character to improve readability when variables or nested patterns are not needed.

Value

Captures developer intent by indicating unused bindings or lambda parameters, clarifying code and reducing errors.

Improves maintainability by identifying declared but unused variables, such as in catch clauses.

Allows multiple patterns in a single case label when they declare no pattern variables.

Enhances readability of record patterns by eliminating unnecessary nested type patterns.

Statements before super (…) (Preview)

JEP 447 allows statements that do not reference the instance being created to appear before an explicit constructor invocation.

Value

Gives developers greater freedom to express constructor behavior without resorting to auxiliary static methods or intermediate constructors.

Preserves the existing guarantee that constructor code runs top‑down during class instantiation, ensuring subclass code does not interfere with superclass initialization.

Requires no changes to the JVM; the feature relies only on the current JVM’s ability to verify and execute code preceding explicit constructor calls.

String Templates (2nd Preview)

JEP 459 adds a second preview of string templates, simplifying the creation of strings that contain runtime‑computed values.

Value

Simplifies Java code by allowing easy expression of strings with embedded runtime values.

Improves readability of mixed text and expressions, whether the text fits on a single line or spans multiple lines.

Enhances security by validating and converting embedded expressions, reducing risks when user‑provided data is incorporated into strings such as database queries.

Retains flexibility by letting Java libraries define the formatting syntax used in string templates.

Simplifies APIs that accept strings written in non‑Java languages (e.g., SQL, XML, JSON).

Enables creation of non‑string values computed from literal text and embedded expressions without an intermediate string representation.

Implicitly Declared Classes and Instance Main Methods (2nd Preview)

JEP 463 allows students to write their first Java programs without needing to understand the full language features required for large applications.

Value

Accelerates Java learning by providing a smooth entry point for beginners.

Allows teachers to introduce concepts incrementally.

Enables students to write concise basic programs and expand them gracefully as their skills grow.

Reduces boilerplate for simple scripts and command‑line utilities.

Requires no separate beginner toolchain; programs compile and run with the standard Java compiler.

Foreign Function & Memory API

JEP 454 introduces an API that lets Java programs interoperate with native code and memory outside the JVM, providing a safer alternative to JNI.

Value

Productivity: replaces fragile native methods and JNI with a concise, pure‑Java API.

Performance: offers access to external functions and memory with overhead comparable to or better than JNI and sun.misc.Unsafe.

Portability: enables discovery and invocation of native libraries on any platform where the JVM runs.

Consistency: provides a uniform way to operate on structured and unstructured data across various memory types.

Safety: prevents use‑after‑free errors even when memory is allocated and freed across threads.

Integrity: allows unsafe operations with native code while warning users by default.

Class‑File API (Preview)

JEP 457 offers a standard API for parsing, generating, and transforming Java class files.

Value

The API enables frameworks and programs that depend on it to automatically support the latest class‑file features introduced in new JDK releases, facilitating rapid adoption of new language and VM capabilities.

Stream Gatherers (Preview)

JEP 461 enhances the Stream API with custom intermediate operations, allowing data transformations not easily expressed with existing built‑in operations.

Value

Improves developer productivity and code readability by making common custom stream operations more flexible and expressive, and supports intermediate operations on streams of unlimited size.

Structured Concurrency (2nd Preview)

JEP 462 simplifies concurrent programming by treating related tasks running in different threads as a single unit of work.

Value

Reduces common risks such as thread leaks and cancellation delays, and enhances observability of concurrent code by promoting a structured programming style.

Scoped Values (2nd Preview)

JEP 464 provides an efficient way to share immutable data within and across threads.

Value

Ease of use: offers a programming model for sharing data inside a thread and with child threads, simplifying reasoning about data flow.

Understandability: makes the lifecycle of shared data visible in the code’s syntactic structure.

Robustness: ensures that only legitimate callers can retrieve shared data.

Performance: treats shared data as immutable, allowing extensive thread sharing and runtime optimizations.

Vector API (7th Incubator)

JEP 460 introduces a Vector API that expresses vector computations, which the runtime can compile to optimal vector instructions on supported CPUs.

Value

Provides a clear, concise API for expressing a wide range of vector calculations.

Designed to be architecture‑agnostic, enabling implementation across multiple platforms with vector instructions.

Delivers reliable runtime compilation and performance on x64 and AArch64 architectures.

Regional Pinning for G1

JEP 423 adds regional pinning to G1 garbage collection, reducing latency during critical JNI regions without disabling GC.

Value

Allows Java threads to continue without waiting for G1 GC to finish when using JNI, improving developer productivity.

Launch Multi‑File Source‑Code Programs

JEP 458 enables running programs supplied as multiple Java source files without prior compilation.

Value

Improves developer productivity by making the transition from small scripts to large applications more gradual, letting developers decide when to configure build tools.

Preview features are fully specified and implemented, allowing feedback before they become permanent parts of the Java SE platform.

Incubator APIs expose non‑final APIs and tools to gather feedback and ultimately enhance the Java platform.

Additional minor updates include deprecations, removals, and improvements that interest application developers and system administrators.

Other Updates

Added extra algorithms to keytool and jarsigner.

Improved garbage‑collector throughput, especially for young generation collections.

Enhanced system module descriptor version reporting.

Improved native code “wait” handling options.

Unicode CLDR data updated to version 44.

Type‑annotation support for types loaded from bytecode.

ForkJoinPool and ForkJoinTasks now handle non‑blocking tasks better.

More flexible TLS configuration for client‑server connections.

Enhanced native‑memory tracking with peak‑usage reporting.