What’s New in Java 22? Explore 12 Key Features and Their Benefits

Java 22 was officially released, bringing twelve enhancements—including seven preview features and one incubator feature—that improve the language, APIs, performance, and tooling.

Unnamed Variables & Patterns – JEP 456

JEP 456 introduces unnamed variables and patterns, using the underscore character to represent unused bindings or nested patterns, improving readability.

Value

Captures developer intent by highlighting unused bindings or lambda parameters, reducing errors.

Identifies declared but unused variables (e.g., in catch clauses), enhancing maintainability.

Allows multiple patterns in a single case label when no pattern variables are declared.

Improves 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 call in a constructor.

Value

Gives developers more freedom to express constructor behavior, reducing the need for auxiliary static methods or intermediate constructors.

Preserves the top‑down execution order of constructors, ensuring subclass code does not interfere with superclass instantiation.

Requires no changes to the JVM; the feature relies only on existing verification and execution capabilities.

String Templates (2nd Preview) – JEP 459

Second preview of string templates, enabling easier expression of strings that contain runtime‑computed values.

Value

Simplifies Java code by allowing concise 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 supporting validation and conversion of template‑embedded values, useful for building queries or other external strings.

Allows libraries to define custom formatting syntax within templates, preserving flexibility.

Facilitates APIs that accept non‑Java‑language strings such as SQL, XML, or 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 learn the full language features required for large applications.

Value

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

Enables teachers to introduce concepts gradually.

Lets students write concise basic programs and scale them elegantly as skills grow.

Reduces boilerplate for simple scripts and command‑line utilities.

Uses the same compilation and runtime tools as any Java program, avoiding a separate beginner toolchain.

Foreign Function & Memory API – JEP 454

Provides a pure‑Java API for interoperating with native code and memory outside the JVM, replacing fragile JNI usage.

Value

Productivity: concise, readable Java API replaces fragile native methods and JNI.

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

Broad platform support: discover and call native libraries on any platform where the JVM runs.

Consistency: operate on structured and unstructured data of unlimited size across various memory types.

Safety: guarantees against use‑after‑free errors even across threads.

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

Class‑File API (Preview) – JEP 457

Introduces a standard API for parsing, generating, and transforming Java class files.

Value

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

Stream Gatherers (Preview) – JEP 461

Enhances the Stream API to support custom intermediate operations, allowing more expressive data transformations.

Value

Improves developer productivity and code readability by making common custom stream operations more flexible and expressive, supporting potentially unbounded streams.

Structured Concurrency (2nd Preview) – JEP 462

Simplifies concurrent programming by treating related tasks running on different threads as a single unit of work.

Value

Reduces common risks such as thread leaks and cancellation delays, improves observability, and simplifies error handling and cancellation.

Scoped Values (2nd Preview) – JEP 464

Implements efficient sharing of immutable data within and across threads.

Value

Ease of use: provides a programming model for sharing data inside a thread and with child threads.

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

Robustness: ensures 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

Provides an API for expressing vector computations that compile to optimal vector instructions on supported CPUs.

Value

Offers a clear, concise API for a wide range of vector calculations, including loops and control flow.

Designed to be CPU‑architecture independent, enabling implementation on multiple platforms with vector instructions.

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

Regional Pinning for G1 – JEP 423

Implements region pinning in G1 to reduce latency, allowing JNI‑critical regions to run without disabling garbage collection.

Value

When using JNI, Java threads no longer need to wait for G1 GC to finish, improving developer efficiency.

Launch Multi‑File Source‑Code Programs – JEP 458

Enables running programs supplied as multiple Java source files without prior compilation.

Value

Facilitates a gradual transition from small to large programs, letting developers choose when to adopt build tools.

Preview features are fully specified and implemented, providing feedback opportunities before becoming permanent.

Incubator APIs expose non‑final features to collect feedback and improve the Java platform.

Additional minor updates (deprecated APIs, etc.) are of interest to many application developers and system administrators.

Other Updates

Additional algorithms to keytool and jarsigner.

Improved garbage‑collector throughput, especially for young generation.

Better system module descriptor version reporting.

Enhanced "wait" handling options for native code.

Unicode CLDR data updated to version 44.

Type‑annotation support for types loaded from bytecode.

ForkJoinPool and ForkJoinTask now handle non‑blocking tasks more effectively.

More flexibility configuring client‑server TLS connection properties.

Improved native‑memory tracking with peak‑usage reporting.