Oracle bringt Java 22 – Oracle Releases Java 22

„Die Verbesserungen in Java 22 ermöglichen es Entwicklern, schnell und einfach funktionsreiche, skalierbare und sichere Anwendungen zu erstellen und bereitzustellen, die das Wachstum globaler Unternehmen unterstützen“, sagte Georges Saab, Senior Vice President, Oracle Java Platform und Vorsitzender des OpenJDK Governing Board. „Durch die Bereitstellung von Verbesserungen, die die Anwendungsentwicklung optimieren und die Reichweite von Java erweitern, um es Entwicklern mit unterschiedlichen Fähigkeiten zugänglich zu machen, wird Java 22 dazu beitragen, die Entwicklung einer breiten Palette neuer Anwendungen und Dienste für Unternehmen und Entwickler gleichermaßen voranzutreiben.“

JDK 22 Verbesserungen

Die Änderungsrate in den JDK-Releases ist seit Jahren weitgehend konstant geblieben, allerdings hat sich die Geschwindigkeit, mit der produktionsreife Funktionen und Verbesserungen ausgeliefert werden, im Rahmen der halbjährlichen Kadenz deutlich erhöht.

Anstelle von Zehntausenden von Bugfixes und fast hundert JEPs (JDK Enhancement Proposals) alle paar Jahre, wie es bei früheren Major Releases der Fall war, werden Verbesserungen in schlankeren Feature Releases in einem überschaubaren und vorhersehbaren Zeitrahmen von sechs Monaten bereitgestellt. Die Änderungen reichen von größeren neuen Funktionen über kleinere Erweiterungen bis hin zu routinemäßigen Wartungsarbeiten, Fehlerbehebungen und Verbesserungen der Dokumentation. Jede Änderung wird in einem einzelnen Commit für ein einzelnes Problem im JDK Bug System dargestellt.

Von den 26.447 JIRA Bugs, die zum Zeitpunkt ihrer Veröffentlichung in Java 11 bis Java 22 als behoben markiert waren, wurden 18.842 von Oracle-Mitarbeitern geschlossen, während 7.605 von einzelnen Entwicklern und Entwicklern, die für andere Unternehmen arbeiten, beigesteuert wurden. Wenn man sich die Ausgaben ansieht und die Organisationsdaten der Beauftragten zusammenstellt, ergibt sich das folgende Diagramm der Organisationen, die die Entwicklung von Beiträgen in Java sponsern:

In Java 22 wurden von den 2.251 als gelöst markierten JIRA-Problemen 1.554 von Oracle gelöst, während 697 von anderen Mitgliedern der Java-Community beigetragen wurden.

Rückkehr der JavaOne 2025

JavaOne, die weltweite Entwicklerkonferenz der Java-Community, kehrt 2025 in die San Francisco Bay Area zurück. Die JavaOne 2025 wird vom 17. bis 20. März 2025 in Redwood Shores, Kalifornien, stattfinden.

Das neue Java Development Kit (JDK) bietet Updates und Verbesserungen mit 12 JDK Enhancement Proposals (JEP‘s). JDK 22 bietet Sprachverbesserungen aus dem OpenJDK Project Amber (Statements before super[…], Unnamed Variables & Patterns, String Templates, and Implicitly Declared Classes and Instance Main Methods), Verbesserungen von Project Panama (Foreign Function & Memory API und Vector API), Features im Zusammenhang mit Project Loom (Structured Concurrency und Scoped Values); wichtige Features von Bibliotheken und Tools (Class File API, Launch Multi-File Source-Code Programs, Stream Gatherers) und Performance-Updates (Region Pinning für G1 GC).

„Nach fast drei Jahrzehnten macht die Fähigkeit von Java, komplexe Entwicklungsaufgaben in einem breiten Spektrum von Anwendungsfällen zu unterstützen, die Plattform relevanter denn je“, so Arnal Dayaratna, Research Vice President, Software Development, IDC. „Dank seiner Vielseitigkeit und der Fülle an Werkzeugen ist Java in der Lage, die Entwicklung produktionstauglicher, geschäftskritischer Anwendungen optimal zu unterstützen. Das macht es zu einer Schlüsseltechnologie für innovative Anwendungsfälle wie die generative KI.“

Wesentliche Merkmale in Java 22 sind:

Project Amber – Features 

• JEP 447: Statements before super(…): Bietet Entwicklern die Möglichkeit, das Verhalten von Konstruktoren auszudrücken. Durch die Möglichkeit, Anweisungen, die nicht auf die erzeugte Instanz verweisen, vor einem expliziten Konstruktoraufruf anzuzeigen, ermöglicht dieses Feature eine natürlichere Platzierung der Logik, die in statischen Hilfsmethoden, zusätzlichen Zwischenkonstruktoren oder Konstruktorargumenten enthalten sein muss. Darüber hinaus wird die bestehende Zusicherung, dass Konstruktoren während der Klasseninstanziierung von oben nach unten ausgeführt werden, beibehalten. Dadurch wird sichergestellt, dass Code in einem Subclass-Konstruktor die Instanziierung der Oberklasse nicht beeinträchtigen kann. Darüber hinaus erfordert dieses Feature keine Änderungen an der Java Virtual Machine und basiert lediglich auf der Fähigkeit der JVM, Code, der in Konstruktoren vor expliziten Konstruktoraufrufen angezeigt wird, zu überprüfen und auszuführen.
• JEP 456: Unnamed Variables & Patterns: Trägt zur Verbesserung der Produktivität von Entwicklern bei, indem die Java-Sprache um Unnamed-Variablen und Pattern erweitert wird, die verwendet werden können, wenn Variablendeklarationen oder verschachtelte Pattern erforderlich sind, aber nie tatsächlich verwendet werden. Dies reduziert mögliche Fehler, verbessert die Lesbarkeit von Record-Pattern und erhöht die Wartbarkeit des gesamten Codes.
• JEP 459: String Templates (Second Preview): Vereinfacht die Entwicklung von Java-Programmen und erleichtert das Ausdrücken von Zeichenfolgen, die zur Laufzeit berechnete Werte enthalten. Außerdem wird die Sicherheit von Programmen verbessert, die Zeichenfolgen aus den von Benutzern bereitgestellten Werten zusammensetzen und sie an andere Systeme weitergeben. Darüber hinaus wird die Lesbarkeit von Ausdrücken verbessert, die mit Text vermischt sind. Non-String-Values können erstellt werden, die aus Literaltext und eingebundenen Ausdrücken berechnet werden, ohne dass eine Überführung in eine Intermediate-String-Darstellung erforderlich ist.
• JEP 463: Implicitly Declared Classes and Instance Main Methods (Second Preview): Trägt zur Beschleunigung des Lernprozesses bei, indem es einen sanften Einstieg in die Java-Programmierung ermöglicht, so dass Schüler ihre ersten Programme schreiben können, ohne die für größere Programme entwickelten Sprachfunktionen im Detail verstehen zu müssen. Diese Funktion ermöglicht es Lehrern, Konzepte schrittweise einzuführen, und Schülern, optimierte Deklarationen für Single-Class-Programme zu schreiben und ihre Programme nahtlos zu erweitern, um anspruchsvollere Funktionen zu nutzen, wenn ihre Fähigkeiten zunehmen.

Project Loom – Features

• JEP 462: Structured Concurrency (Second Preview): Unterstützt Entwickler bei der gezielten Fehlerbehandlung und-behebung und verbessert die Überwachung durch die Einführung einer Structured-Concurrency-API. Dies trägt dazu bei, einen Concurrent-Programmier-Stil zu fördern, der vorhandene Risiken beseitigen kann, die sich aus dem Abbruch und dem Herunterfahren ergeben (zum Beispiel Thread-Leaks und Abbruchverzögerungen) und die Überwachung von nebenläufigem Code verbessert.
• JEP 464: Scoped Values (Second Preview): Trägt dazu bei, die Benutzerfreundlichkeit, Verständlichkeit, Performance und Robustheit von Entwicklerprojekten zu verbessern, indem die gemeinsame Nutzung unveränderlicher Daten innerhalb und zwischen Threads ermöglicht wird.

Project Panama – Features 

• JEP 454: Foreign Function & Memory API: Verbessert die Benutzerfreundlichkeit, Flexibilität, Sicherheit und Leistung für Entwickler durch die Einführung einer API, die es Java-Programmen ermöglicht, mit Code und Daten außerhalb der Java-Laufzeitumgebung zu interagieren. Durch den effizienten Aufruf von Fremdfunktionen, wie Code außerhalb der Java Virtual Machine (JVM) und durch den sicheren Zugriff auf Fremd-Memory (das heißt Memory, der nicht von der JVM verwaltet wird) ermöglicht diese neue API Java-Programmen ohne erforderliches Java Native Interface (JNI), native Bibliotheken aufzurufen und native Daten zu verarbeiten.
• JEP 460: Vector API (Seventh Incubator): Führt eine API zum Formulieren von Vektorberechnungen ein, die zur Laufzeit zuverlässig in Vektoranweisungen für die unterstützten Prozessorarchitekturen kompiliert werden. Dies hilft Entwicklern, die Projektperformance zu verbessern, da ihnen API-Zugriff gewährt wird, um ein breites Spektrum an Vektorberechnungen klar und prägnant auszudrücken.

Core-Bibliotheken und Tools

• JEP 457: Class-File API (Preview): Unterstützt Entwickler, ihre Produktivität zu steigern, indem es eine Standard-API zum Parsen, Generieren und zum Transformieren von Java-Class-Files bereitstellt.
• JEP 458: Launch Multi-File Source-Code Programs: Ermöglicht es Entwicklern zu entscheiden, ob und wann ein Build-Tool konfiguriert werden soll, indem der Java Application Launcher so erweitert wird, dass er ein Programm ausführen kann, das durch mehrere Dateien mit Java-Quellcode bereitgestellt wird.
• JEP 461: Stream Gatherers (Preview): Hilft Entwicklern, ihre Produktivität zu steigern, indem die Stream API erweitert wird, um benutzerdefinierte Intermediate-Operationen zu unterstützen. Dadurch können Stream-Pipelines Daten transformieren, die mit den vorhandenen Intermediate-Operationen nicht einfach zu erreichen sind. Durch flexiblere und aussagekräftigere Stream-Pipelines und benutzerdefinierte Intermediate-Operationen zur Bearbeitung von Streams unendlicher Größe, ermöglicht dieses Merkmal den Entwicklern eine höhere Effizienz beim Lesen, Schreiben und Warten von Java-Code.

Performance-Updates 

• JEP 423: Region Pinning for G1: Trägt zur Reduzierung der Latenz bei und ermöglicht die Durchführung einer Garbage Collection während nativer Bibliotheksaufrufe, die ansonsten eine Pause des Garbage Collectors erfordern würden. Dies wird erreicht, indem während eines Aufrufs einer nativen Bibliothek verfolgt wird, welche Objekte blockiert werden müssen, und nur die Regionen „gepinnt“ werden, die diese Objekte enthalten. Auf diese Weise kann die Garbage Collection in den nicht gepinnten Regionen normal fortgesetzt werden, insbesondere während eines ansonsten blockierenden nativen Bibliotheksaufrufs.

Die Veröffentlichung von Java 22 ist das Ergebnis der kontinuierlichen Zusammenarbeit zwischen Oracle und anderen Mitgliedern der weltweiten Java-Entwickler-Community vom OpenJDK und dem Java Community Process (JCP). Neben Verbesserungen und neuen Merkmalen wird Java 22 vom Java Management Service unterstützt – einem Oracle Cloud Infrastructure-(OCI-)Service. Dieser Service bietet Unternehmen eine einheitliche Konsole und ein zentrales Dashboard, mit denen die Java-Laufzeiten und -Anwendungen On-Premises oder in jeder Cloud administriert werden können.

Unterstützung des globalen Java-Ökosystems mit Innovation in der Cloud

Java bietet mehr Leistung, Effizienz, Innovation und Kosteneinsparungen, wenn es in der Cloud auf OCI bereitgestellt wird, einem der ersten Hyperscale-Cloud-Systeme, das Java 22 unterstützt. Durch die kostenlose Bereitstellung von Oracle Java SE, Oracle GraalVM und dem Java SE Subscription Enterprise Performance Pack auf OCI ermöglicht Java 22 Entwicklern die Erstellung und Bereitstellung von Anwendungen, die schneller, besser und mit einem optimierten Kosten-Nutzen-Verhältnis laufen.

Die Oracle Java Universal SE Subscription ist ein Pay-as-you-go-Angebot, das Kunden professionellen Support bietet. Es umfasst Triage-Support für das gesamte Java-Portfolio, die Nutzung von Oracle GraalVM, das Java SE Subscription Enterprise Performance Pack sowie Zugang zu Java Management Services und die Flexibilität, erforderliche Upgrades im Unternehmenstempo durchzuführen. Auf diese Weise können IT-Organisationen die Komplexität beherrschen, Kosten begrenzen und Sicherheitsrisiken verringern.

„The enhancements in Java 22 enable developers to quickly and easily build and deploy feature-rich, scalable and secure applications that support the growth of global enterprises,“ said Georges Saab, senior vice president, Oracle Java Platform and chairman of the OpenJDK Governing Board. „By delivering enhancements that streamline application development and extend the reach of Java to make it accessible to developers of all skill levels, Java 22 will help drive the development of a wide range of new applications and services for enterprises and developers alike.“

Return of JavaOne 2025

JavaOne, the global developer conference for the Java community, will return to the San Francisco Bay Area in 2025. JavaOne 2025 will be held March 17-20, 2025 in Redwood Shores, California.

New with Java 22

JDK 22 delivers 12 enhancements that are significant enough to warrant their own JDK Enhancement Proposals (JEPs), including seven preview features and one incubator feature.   They cover improvements to the Java Language, its APIs, its performance, and the tools included in the JDK.

1) Language Improvements:

Unnamed Variables & Patterns – JEP 456

Improves readability when variable declarations or nested patterns are required but not used. Both are denoted by the underscore character

Value:

Captures developer intent that a given binding or lambda parameter is unused, and enforces that property to clarify programs and reduce opportunities for error.

Improves the maintainability of all code by identifying variables that must be declared (e.g., in catch clauses) but are not used.

Allows multiple patterns to appear in a single case label, if none of them declare any pattern variables.

Improves the readability of record patterns by eliding unnecessary nested type patterns.

1.1) Language Previews

Statements before super (…) [Preview] – JEP 447:

In constructors, allow for statements that do not reference the instance being created to appear before an explicit constructor invocation.

Value:

Gives developers greater freedom to express the behavior of constructors, enabling the more natural placement of logic that currently must be factored into auxiliary static methods, auxiliary intermediate constructors, or constructor arguments.

Preserves the existing guarantee that constructors run in top-down order during class instantiation, ensuring that code in a subclass constructor cannot interfere with superclass instantiation.

Does not require any changes to the Java Virtual Machine. This Java language feature relies only on the current ability of the JVM to verify and execute code that appears before explicit constructor invocations within constructors.

String Templates (Second Preview) – JEP 459:

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.

Value:

Simplifies the writing of Java programs by making it easy to express strings that include values computed at run time.

Enhances 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).

Improves 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.

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

Simplifies the use of APIs that accept strings written in non-Java languages (e.g., SQL, XML, and JSON).

Enables the creation of non-string values computed from literal text and embedded expressions without having to transit through an intermediate string representation.

Implicitly Declared Classes and Instance Main Methods (Second Preview) – JEP 463:

Students can write their first Java programs without needing to understand language features designed for large programs. Instead of 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.

Value:

To accelerate learning of Java –

Offers a smooth on-ramp to Java programming so that instructors can introduce concepts in a gradual manner.

Helps students to write basic programs in a concise manner and grow their code gracefully as their skills grow.

Reduces the ceremony of writing simple programs such as scripts and command-line utilities.

Does not introduce a separate beginners‘ dialect of the Java language.

Does not introduce a separate beginners‘ toolchain; student programs should be compiled and run with the same tools that compile and run any Java program.

2) Libraries

Foreign Function & Memory API – JEP 454:

Allows Java programs to 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.

Value:

Productivity — Replace the brittle machinery of native methods and the Java Native Interface (JNI) with a concise, readable, and pure-Java API.

Performance — Provide access to foreign functions and memory with overhead comparable to, if not better than, JNI and sun.misc.Unsafe.

Broad platform support — Enable the discovery and invocation of native libraries on every platform where the JVM runs.

Uniformity — Provide ways to operate on structured and unstructured data, of unlimited size, in multiple kinds of memory (e.g., native memory, persistent memory, and managed heap memory).

Soundness — Guarantee no use-after-free bugs, even when memory is allocated and deallocated across multiple threads.

Integrity — Allow programs to perform unsafe operations with native code and data but warn users about such operations by default.

2.1) Library Previews and Incubator

Class-File API (Preview) – JEP 457:

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

Value:

The API allows frameworks and programs that rely on it to support the latest class files from the latest JDK automatically, so that the new language and VM features with representation in class files could be adopted quickly and easily.

Stream Gatherers (Preview) – JEP 461:

Enhances 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.

Value:

Improves developer productivity and code readability by making common custom operations in streams more flexible and expressive. As much as possible, allows intermediate operations to manipulate streams of infinite size.

Structured Concurrency (2nd Preview) – JEP 462:

Simplifies concurrent programming. 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.

Value:

Simplifies development of concurrent code by promoting a style of programming that can eliminate common risks arising from cancellation and shutdown, such as thread leaks and cancellation delays, and improves the observability of concurrent code.

Scoped Values (2nd Preview) – JEP 464:

Enables efficient sharing of immutable data within and across threads.

Value:

Ease of use — Provides a programming model to share data both within a thread and with child threads, to simplify reasoning about data flow.

Comprehensibility — Makes the lifetime of shared data visible from the syntactic structure of code.

Robustness — Ensures that data shared by a caller can be retrieved only by legitimate callees.

Performance — Treats shared data as immutable to allow sharing by a large number of threads, and to enable runtime optimizations.

Vector API (7th Incubator) – JEP 460:

An API to express vector computations that reliably compile at runtime to optimal vector instructions on supported CPU architectures, thus achieving performance superior to equivalent scalar computations.

This JEP proposes to re-incubate the API in JDK 22, with minor enhancements in the API relative to JDK 21. The implementation includes bug fixes and performance enhancements. We include the following notable changes:

Support vector access with heap MemorySegments that are backed by an array of any primitive element type. Previously access was limited to heap MemorySegments backed by an array of byte.

Value:

Offers a clear and concise API that is capable of clearly and concisely expressing a wide range of vector computations consisting of sequences of vector operations composed within loops, and possibly with control flow.

The API is designed to be CPU architecture agnostic, enabling implementations on multiple architectures supporting vector instructions.

Offers a reliable runtime compilation and performance on x64 and AArch64 architectures.

Aligns with Project Valhalla.

3) Performance

Regional Pinning for G1 – JEP 423:

Reduces latency by implementing regional pinning in G1, so that garbage collection need not be disabled during Java Native Interface (JNI) critical regions.

Value:

Improves developer productivity by eliminating the need for Java threads to wait before G1 GC operation to complete while using JNI.

4) Tooling

Launch Multi-File Source-Code Programs – JEP 458:

Allows users to run a program supplied as multiple files of Java source code without first having to compile it.

Value:

Improves developer productivity by making the transition from small programs to larger ones more gradual, enabling developers to choose whether and when to go to the trouble of configuring a build tool.

Note that preview features are fully specified and fully implemented Language or VM Features of the Java SE Platform, but are impermanent. They are made available in JDK Feature Releases to allow for developer feedback based on real-world uses, before them becoming permanent in a future release. This also affords tool vendors the opportunity to work towards supporting features before they are finalized into the Java SE Standard.

APIs in Incubator modules put non-final APIs and non-final tools in the hands of developers and users to gather feedback that will ultimately improve the quality of the Java platform.

Besides the changes described in the JEPs, there are many smaller updates listed in the release notes which will be of interest to many application developers and system administrators. These include deprecation of obsolete APIs and removal of previously deprecated ones.

Some of the key updates from the Java 22 release notes:

Addition of additional algorithms to keytool and jarsigner.

Garbage collector throughput improvements especially as it relates to “young” garbage.

Better version reporting for system module descriptors.

Improved “wait” handling options for native code.

Unicode Common Locale Data Repository has been updated to version 44.

Type annotations support for types loaded from bytecode.

ForkJoinPool and ForJoinTasks can now better handle uninterruptable tasks.

Additional flexibility for configuring client versus server TLS connection properties.

Improved native memory tracking including ability to report peak usage.

Finally, like all Feature releases, JDK 22 includes hundreds of performance, stability, and security updates including adapting to underlying OS and firmware updates and standards.  Users and application developers usually benefit from these changes without noticing them.

And the constant feature included in all JDK releases: Predictability

JDK 22 is the 13th Feature Release delivered on time through the six-month release cadence. This level of predictability allows developers to easily manage their adoption of innovation thanks to a steady stream of expected improvements.

Java’s ability to boost performance, stability, and security continues to make it the world’s most popular programming language.

Oracle will not offer long-term support for JDK 22; we will provide updates until September 2023 when it will be superseded by Oracle JDK 23.

Java 22, Together

As with previous releases, Java 22 celebrates the contributions of many individuals and organizations in the OpenJDK Community — we all build Java, together!

JDK 22 Fix Ratio

The rate of change over time in the JDK releases has remained largely constant for years, but under the six-month cadence the pace at which production-ready features and improvements are delivered has sharply increased.

Instead of making tens of thousands of fixes and delivering close to one hundred JEPs (JDK Enhancement Proposals) every few years, as we did with past Major Releases, enhancements are delivered in leaner Feature Releases on a more manageable and predictable six-month schedule. The changes range from significant new features to small enhancements to routine maintenance, bug fixes, and documentation improvements. Each change is represented in a single commit for a single issue in the JDK Bug System.

Of the 26,447 JIRA issues marked as fixed in Java 11 through Java 22 at the time of their GA, 18,842 were completed by Oracle employees while 7,605 were contributed by individual developers and developers working for other organizations. Going through the issues and collating the organization data from assignees results in the following chart of organizations sponsoring the development of contributions in Java:

In Java 22, of the 2,251 JIRA issues marked as fixed, 1,554 were completed by Oracle, while 697 were contributed by other members of the Java community.