The Major new functionality in Java 21

Below are major new functionality in java 21 which will help one to understand the JDK 21 version. The below points will describe each functionality in java 21.

Record Patterns

To deconstruct record values one can enhance the Java programming language with record patterns. Record patterns and type patterns can be nested to enable a powerful, declarative, and composable form of data navigation and processing.

We extend the Java programming language with nestable record patterns.

The grammar for patterns becomes:

Pattern:
  TypePattern
  RecordPattern

TypePattern:
  LocalVariableDeclaration

RecordPattern:
  ReferenceType ( [ PatternList ] )

PatternList : 
  Pattern { , Pattern }

Pattern Matching for switch

With pattern matching for switch expressions and statements we can enhance the Java programming language. Extending pattern matching to switch allows an expression to be tested against a number of patterns, each with a specific action, so that complex data-oriented queries can be expressed concisely and safely.

String Templates (Preview)

One can enhance the implementation of java by string templates. String templates complement Java’s existing string literals and text blocks by coupling literal text with embedded expressions and template processors to produce specialized results. This is a preview language feature and API.

Simplify the writing of Java programs by making it easy to express strings that include values computed at run time.
Enhance the readability of expressions that mix text and expressions, whether the text fits on a single source line (as with string literals) or spans several source lines (as with text blocks).
Improve the security of Java programs that compose strings from user-provided values and pass them to other systems (e.g., building queries for databases) by supporting validation and transformation of both the template and the values of its embedded expressions.
Retain flexibility by allowing Java libraries to define the formatting syntax used in string templates.
Simplify the use of APIs that accept strings written in non-Java languages (e.g., SQL, XML, and JSON).
Enable the creation of non-string values computed from literal text and embedded expressions without having to transit through an intermediate string representation.

Unnamed Patterns and Variables (Preview)

This is a preview feature and enhance the Java language with unnamed patterns, which match a record component without stating the component’s name or type, and unnamed variables, which can be initialized but not used. Both are denoted by an underscore character, _.

Unnamed Classes and Instance Main Methods (Preview)

This functionality in java 21 is a preview language feature which evolve the Java language so that students can write their first programs without needing to understand language features designed for large programs. Far from using a separate dialect of Java, students can write streamlined declarations for single-class programs and then seamlessly expand their programs to use more advanced features as their skills grow.

Key Encapsulation Mechanism API

An API for key encapsulation mechanisms (KEMs), an encryption technique for securing symmetric keys using public key cryptography.

Sequenced Collections

This interface represent collections with a defined encounter order. It has a well-defined first element, second element, and so forth, up to the last element. It also provides uniform APIs for accessing its first and last elements, and for processing its elements in reverse order.

“Life can only be understood backwards; but it must be lived forwards.”
— Kierkegaard

Virtual Threads

Introduce virtual threads to the Java Platform. Virtual threads are lightweight threads that dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications.

Generational ZGC - Performance Improvements

Improve application performance by extending the Z Garbage Collector (ZGC) to maintain separate generations for young and old objects. This will allow ZGC to collect young objects — which tend to die young — more frequently.

Applications running with Generational ZGC should enjoy

Lower risks of allocations stalls,
Lower required heap memory overhead, and
Lower garbage collection CPU overhead.

These benefits should come without significant throughput reduction compared to non-generational ZGC. The essential properties of non-generational ZGC should be preserved:

Pause times should not exceed 1 millisecond,
Heap sizes from a few hundred megabytes up to many terabytes should be supported, and
Minimal manual configuration should be needed.

As examples of the last point, there should be no need to manually configure

The size of the generations,
The number of threads used by the garbage collector, or
For how long objects should reside in the young generation.

Finally, Generational ZGC should be a better solution for most use cases than non-generational ZGC. We should eventually be able to replace the latter with the former in order to reduce long-term maintenance costs.