Work on features in the Java SE 22 Reference Implementation is
organized in terms of JDK Enhancement Proposals (JEPs).
Each feature
description gives a link to the corresponding JEP document as a
convenience, but that document is not a normative part of this
Specification. Some features are included in the Java SE 22 Reference
Implementation on a preview basis, to gain
exposure before achieving permanent status in a later release of the
Java SE Platform.
Summary
Libraries
Class-File API (Preview)
Provide a standard API for parsing, generating, and transforming Java class
files. This is a preview API.
Foreign Function & Memory API
Introduce an API by which Java programs can interoperate with code and data outside of the Java runtime. By efficiently invoking foreign functions (i.e., code outside the JVM), and by safely accessing foreign memory (i.e., memory not managed by the JVM), the API enables Java programs to call native libraries and process native data without the brittleness and danger of JNI.
Scoped Values (Second Preview)
Introduce scoped values, which enable managed sharing of immutable data both with child frames in the same thread, and with child threads. Scoped values are easier to reason about than thread-local variables and have lower space and time costs, especially when used in combination with Virtual Threads and Structured Concurrency. This is a preview API.
Stream Gatherers (Preview)
Enhance the Stream API to support custom intermediate operations. This will allow stream pipelines to transform data in ways that are not easily achievable with the existing built-in intermediate operations. This is a preview API.
Structured Concurrency (Second Preview)
Simplify concurrent programming by introducing an API for structured concurrency. Structured concurrency treats groups of related tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability. This is a preview API.
Language
Implicitly Declared Classes and Instance Main Methods (Second Preview)
Evolve the Java programming 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 the language, students can write streamlined declarations for single-class programs and then seamlessly expand their programs to use more advanced features as their skills grow. This is a preview language feature.
Statements before super(...) (Preview)
In constructors in the Java programming language, allow statements that do not
reference the instance being created to appear before an explicit constructor
invocation. This is a preview language feature.
String Templates (Second Preview)
Enhance the Java programming language with 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.
Unnamed Variables & Patterns
Enhance the Java programming language with unnamed variables and unnamed
patterns, which can be used when variable declarations or nested patterns are
required but never used. Both are denoted by the underscore character, _.
Preview features
A preview feature is a new feature of the Java language, Java Virtual
Machine, or Java SE API that is fully specified, fully implemented, and
yet impermanent.
Preview features must possess
the following properties:
- High quality. A preview feature must display the same level
of technical excellence and finesse as a final and permanent feature of
the Java SE Platform.
- Not experimental. A preview feature must not be
experimental, risky, incomplete, or unstable. An experimental feature
must not be previewed in a release of the Java SE Platform.
- Universally available. All preview features included in a
Java SE Platform Specification must be supported in full by every
implementation of that Specification.
Preview features may be removed in a future release, or upgraded to
permanent features of the Java SE Platform.
The Java SE API consists solely of Java APIs, but the complete
Java SE Platform includes non-Java APIs, such as JNI and JVM TI, and
language-independent protocols, such as
JDWP and
Java Object Serialization.
A preview feature may include changes to non-Java APIs and
language-independent protocols.
Implementations of this Specification must:
- support all, and only, the preview features included by this
Specification.
- disable all preview features in the Java language, Java Virtual
Machine, and Java SE API at compile time and run time by default.
- allow the user to indicate to the Java compiler and the Java
runtime that the entire set of preview features are to be enabled.
- not allow the user to enable preview features on an individual
basis, because they have equal status in the Platform and must be
enabled or disabled as a set.
- always enable the non-Java APIs and language-independent protocols
that are part of any preview feature, regardless of whether preview
features are enabled or disabled.
Additional details about preview features, including a description of
a
preview feature’s life cycle and the
relationship of preview features in the Java language to preview features
in the Java SE API, are available in
JEP 12 Preview Features.
This section may be compared to
the corresponding section that appeared in Java SE 18.
Restricted methods
Various methods in the Java SE API allow Java code to interoperate with
resources outside the Java runtime in such a way that the runtime cannot
prove correct or safe use of the resources. These methods, which are
provided because of their high utility, are specified as having the
potential to crash the Java runtime or corrupt memory. They are known as
restricted methods.
All methods in the Java SE API that are not restricted are
unrestricted. Given the potential danger of restricted methods,
developers should use restricted methods only when no suitable
functionality is available in unrestricted methods. To encourage
developers to seek unrestricted alternatives to restricted methods, the
following rule applies:
- An Implementation must issue a warning on the standard error
stream
every time a restricted method is invoked, unless (1) the
invocation
occurs in a class in the java.base module, or (2) the
invocation occurs in a class in a module identified previously to
ModuleLayer.Controller.enableNativeAccess, or (3) as
provided for
below.
An Implementation may provide a means to invoke its run-time system
with all restricted methods treated as unrestricted when invoked from
code identified to the run-time system.
If the run-time system is invoked in this way, then by definition
there are no restricted methods for the identified code to invoke, so no
warnings are issued during the execution of such code.
If code other than that identified to the run-time system invokes a
restricted method, the Implementation may give a signal other than a
warning issued on the standard error stream.
(The Reference Implementation provides the ability to treat
restricted methods as unrestricted for code in certain modules via
the command-line option --enable-native-access=M.
M is a comma-separated list of modules whose code is
permitted to invoke restricted methods as if they were unrestricted, i.e.,
without warnings. The special operand
ALL-UNNAMED
indicates every unnamed module, which includes code on the class
path. When the --enable-native-access option is present, any
invocation of restricted methods from code outside the listed modules will
cause an IllegalCallerException to be thrown, rather than a
warning to be issued.)
The list of restricted methods may be found in the
Restricted Methods section of the
API Specification.
Compared to Java SE 21, this Specification does not add or
remove any restricted methods.
Preparing for removal of finalization
An Implementation must support the finalization of objects, as described in
The Java Language Specification, section 12.6. However,
the Java SE 18 Platform Specification
deprecates finalization, for removal. To aid preparations for
the removal of finalization, an Implementation may provide a means
to invoke its run-time system with finalization disabled. If
finalization is disabled, the effect is that the Java Virtual
Machine never invokes an object’s finalizer before the storage for
the object is reclaimed by the garbage collector. An
Implementation must not, by default, disable finalization.
(The Reference Implementation provides the ability to disable
finalization via the command-line option
--finalization=disabled.)
Future revisions of this Platform Specification are expected to
disable finalization by default and, eventually, to remove finalization
from the Java Language Specification.
