{"id":38619,"date":"2023-12-07T02:06:34","date_gmt":"2023-12-07T01:06:34","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=38619"},"modified":"2025-06-12T08:22:26","modified_gmt":"2025-06-12T06:22:26","slug":"java-22-features","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/java-22-features\/","title":{"rendered":"Java 22 Features (mit Beispielen)"},"content":{"rendered":"\n<p class=\"wp-block-paragraph\">Java 22 wurde am 19. M\u00e4rz 2024 ver\u00f6ffentlicht. Du kannst es <a href=\"https:\/\/jdk.java.net\/22\/\" target=\"_blank\" rel=\"noopener\">hier<\/a> herunterladen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die Highlights von Java 22:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Die Finalisierung von <a href=\"#Unnamed_Variables_Patterns_JEP_456\">Unnamed Variables &amp; Patterns<\/a>.<\/li>\n\n\n\n<li><a href=\"#launch-multi-file-source-code-programs-jep-458\">Launch Multi-File Source-Code Programs<\/a> \u2013 starte Programme, die aus mehreren <em>.java<\/em>-Dateien bestehen, ohne sie vorab zu kompilieren.<\/li>\n\n\n\n<li><a href=\"#Statements_before_super_Preview_JEP_447\">Statements before super(...)<\/a> \u2013 wir d\u00fcrfen nun in Konstruktoren auch vor dem Aufruf von <code>super(...)<\/code> oder <code>this(...)<\/code> Code auszuf\u00fchren (mit einigen Einschr\u00e4nkungen).<\/li>\n\n\n\n<li>Schreibe intermedi\u00e4ren Stream-Operationen mit <a href=\"#Stream_Gatherers_Preview_JEP_461\">Stream Gatherers<\/a>.<\/li>\n\n\n\n<li>Die Finalisierung der <a href=\"#Foreign_Function_Memory_API_JEP_454\">Foreign Function &amp; Memory API<\/a> nach sage und schreibe 8 (!) Incubator- und Preview-Runden.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Zudem gehen die in Java 21 als Preview eingef\u00fchrten Features <a href=\"#Structured_Concurrency_Second_Preview_JEP_462\">Structured Concurrency<\/a>, <a href=\"#Scoped_Values_Second_Preview_JEP_464\">Scoped Values<\/a>, <a href=\"#String_Templates_Second_Preview_JEP_459\">String Templates<\/a> ohne \u00c4nderungen in eine zweite Preview-Runde. Und die ebenfalls in Java 21 als Preview eingef\u00fchrten \u201eUnnamed Classes and Instance Main Methods\u201d wurde noch einmal \u00fcberarbeitet und umbenannt in <a href=\"#Implicitly_Declared_Classes_and_Instance_Main_Methods_Second_Preview_JEP_463\">Implicitly Declared Classes and Instance Main Methods<\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr alle JEPs und sonstigen \u00c4nderungen verwende ich wie immer die originalen, englischen Bezeichnungen.<\/p>\n\n\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"unnamed-variables-patterns-jep-456\">Unnamed Variables &amp; Patterns \u2013 JEP 456<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Oft m\u00fcssen wir Variablen definieren, die wir gar nicht ben\u00f6tigen. G\u00e4ngige Beispiele sind z. B. Exceptions, Lambda-Parameter, und Patterns.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Im folgenden Beispiel verwenden wir die Exception-Variable <code>e<\/code> nicht:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-2\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">try<\/span> {\n  <span class=\"hljs-keyword\">int<\/span> number = Integer.parseInt(string);\n} <span class=\"hljs-keyword\">catch<\/span> (NumberFormatException e) {\n  System.err.println(<span class=\"hljs-string\">\"Not a number\"<\/span>);\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-2\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Hier verwenden wir den Lambda-Paraketer <code>k<\/code> nicht:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-3\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">map.computeIfAbsent(key, k -&gt; <span class=\"hljs-keyword\">new<\/span> ArrayList&lt;&gt;()).add(value);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-3\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Und im folgenden Record-Pattern verwenden wir die Pattern-Variable <code>position2<\/code> nicht:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-4\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">if<\/span> (<span class=\"hljs-function\">object <span class=\"hljs-keyword\">instanceof<\/span> <span class=\"hljs-title\">Path<\/span><span class=\"hljs-params\">(Position(<span class=\"hljs-keyword\">int<\/span> x1, <span class=\"hljs-keyword\">int<\/span> y1)<\/span>, Position position2)) <\/span>{\n  System.out.printf(<span class=\"hljs-string\">\"object is a path starting at x = %d, y = %d%n\"<\/span>, x1, y1));\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-4\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Alle drei Code-Beispiele k\u00f6nnen in Java 22 mit unbenannten Variablen und unbenannten Patterns ausdrucksst\u00e4rker formuliert werden, indem die Namen der Variablen oder das komplette Pattern durch den Unterstrich (_) ersetzt werden:<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die Exception-Variable <code>e<\/code> k\u00f6nnen wir durch <code>_<\/code> ersetzen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-5\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">try<\/span> {\n  <span class=\"hljs-keyword\">int<\/span> number = Integer.parseInt(string);\n} <span class=\"hljs-keyword\">catch<\/span> (NumberFormatException _) {\n  System.err.println(<span class=\"hljs-string\">\"Not a number\"<\/span>);\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-5\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Den Lambda-Parameter <code>k<\/code> k\u00f6nnen wir durch <code>_<\/code> ersetzen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-6\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">map.computeIfAbsent(key, _ -&gt; <span class=\"hljs-keyword\">new<\/span> ArrayList&lt;&gt;()).add(value);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-6\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Und das komplette Teil-Pattern <code>Position position2<\/code> k\u00f6nnen wir durch _ ersetzen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-7\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">if<\/span> (<span class=\"hljs-function\">object <span class=\"hljs-keyword\">instanceof<\/span> <span class=\"hljs-title\">Path<\/span><span class=\"hljs-params\">(Position(<span class=\"hljs-keyword\">int<\/span> x1, <span class=\"hljs-keyword\">int<\/span> y1)<\/span>, _)) <\/span>{\n  System.out.printf(<span class=\"hljs-string\">\"object is a path starting at x = %d, y = %d%n\"<\/span>, x1, y1));\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-7\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Unnamed Variables &amp; Patterns wurde in <a href=\"\/de\/java\/java-21-features\/#Unnamed_Patterns_and_Variables_Preview_JEP_443\">Java 21<\/a> als Preview-Feature unter dem Namen \u201eUnnamed Patterns and Variables\u201d ver\u00f6ffentlicht und wird in Java 22 durch <a href=\"https:\/\/openjdk.org\/jeps\/456\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 456<\/a> ohne \u00c4nderungen finalisiert.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Eine ausf\u00fchrlichere Beschreibung findest du im <a href=\"\/de\/java\/unbenannte-variablen-und-patterns\/\">Hauptartikel \u00fcber unbenannte Variablen und Patterns<\/a>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"launch-multi-file-source-code-programs-jep-458\">Launch Multi-File Source-Code Programs \u2013 JEP 458<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Seit <a href=\"\/de\/java\/java-11-features\/#Launch_Single-File_Source-Code_Programs\">Java 11<\/a> k\u00f6nnen wir Java-Programme, die aus nur einer Datei bestehen, direkt ausf\u00fchren, ohne sie vorher kompilieren zu m\u00fcssen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Speichere z. B. einmal den folgenden Java-Code in der Datei <em>Hello.java<\/em>:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-8\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">Hello<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n    System.out.printf(<span class=\"hljs-string\">\"Hello %s!%n\"<\/span>, args&#091;<span class=\"hljs-number\">0<\/span>]);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-8\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Du brauchst dieses Programm nicht, wie vor Java 11, erst mit <code>javac<\/code> zu kompilieren, sondern kannst es direkt ausf\u00fchren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-9\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">$ java Hello.java World\nHello World!<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-9\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Wir k\u00f6nnen in der Datei <em>Hello.java<\/em> auch mehrere Klassen definieren, doch wenn unser Programm w\u00e4chst, wird das schnell un\u00fcbersichtlich; die anderen Klassen sollten in eigenen Dateien definiert werden und in einer sinnvollen Paketstruktur organisiert werden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Sobald wir aber weitere Java-Dateien hinzuf\u00fcgen, funktioniert der sogennante \u201eLaunch Single-File Source-Code\u201d-Mechanismus aus Java 11 nicht mehr.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Lass uns einmal die Berechnung der Begr\u00fc\u00dfung in eine andere Klasse auslagern und diese in der Datei <em>Greetings.java<\/em> speichern:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-10\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">Greetings<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> String <span class=\"hljs-title\">greet<\/span><span class=\"hljs-params\">(String name)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">return<\/span> <span class=\"hljs-string\">\"Hello %s!%n\"<\/span>.formatted(name);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-10\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Die <code>Hello<\/code>-Klasse lassen wir wie folgt die <code>Greetings<\/code>-Klasse verwenden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-11\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">Hello<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n    System.out.println(Greetings.greet(args&#091;<span class=\"hljs-number\">0<\/span>]));\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-11\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Wenn wir das Programm nun direkt mit java starten wollen, passierte \u2013 jedenfalls bis Java 21 \u2013 folgendes:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-12\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">$ java Hello.java World \nHello.java:5: error: cannot find symbol\n    System.out.println(Greetings.greet(args&#091;0]));\n                       ^\n  symbol:   variable Greetings\n  location: class Hello\n1 error\nerror: compilation failed<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-12\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Die <code>Greetings<\/code>-Klasse wurde nicht gefunden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Versuchen wir es noch einmal mit Java 22:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-13\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">$ java Hello.java World \nHello World!<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-13\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Aus dem \u201eLaunch Single-File Source-Code\u201d-Feature wurde in Java 22 ein \u201eLaunch Multi-File Source-Code Programs\u201d-Feature. Der Code darf nun in beliebig vielen Java-Dateien strukturiert sein.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Folgende Besonderheiten musst du dabei beachten:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>W\u00fcrde die <code>Greetings<\/code>-Klasse nicht nur in der Datei <em>Greetings.java<\/em>, sondern ebenfalls in der Datei <em>Hello.java<\/em> definiert sein, dann w\u00fcrde das <code>java<\/code>-Kommando die in der Datei <code>Hello.java<\/code> definierte Klasse verwenden. Es w\u00fcrde die Datei <em>Greetings.java<\/em> gar nicht erst suchen und somit auch keine Fehlermeldung ausgeben, dass die Klasse doppelt definiert ist.<\/li>\n\n\n\n<li>Wenn die Datei <em>Hello.java<\/em> in einem Paket liegen w\u00fcrde, beispielsweise in <em>eu.happycoders.java22<\/em>, dann muss sie auch im entsprechenden Verzeichnis <em>eu.happycoders.java22<\/em> liegen, und du musst das <code>java<\/code>-Kommando im Root-Verzeichis wie folgt aufrufen: <br><code>java eu\/happycoders\/java22\/Hello.java World<\/code> <\/li>\n\n\n\n<li>M\u00f6chtest du Code aus JAR-Dateien verwenden, kannst du diese z. B. in ein Verzeichnis <em>libs<\/em> legen und das <code>java<\/code>-Kommando dann mit der VM-Option <nobr><code>--class-path 'libs\/*'<\/code><\/nobr> aufrufen.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">Definiert ist dieses Feature in <a href=\"https:\/\/openjdk.org\/jeps\/458\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 458<\/a>. Dort wird auch erkl\u00e4rt, wie das Feature bei der Verwendung von Modulen funktioniert, und wie einige Sonderf\u00e4lle, die theoretisch eintreten k\u00f6nnten, behandelt werden. Ich denke aber, dass f\u00fcr die meisten Anwendungsf\u00e4lle das hier beschriebene ausreichend sein sollte. <\/p>\n\n\n<div class=\"convertkit-form wp-block-convertkit-form\" style=\"\"><script async data-uid=\"1427197203\" src=\"https:\/\/happycoders.kit.com\/1427197203\/index.js\" data-jetpack-boost=\"ignore\" data-no-defer=\"1\" data-no-optimize=\"1\" nowprocket><\/script><\/div>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"foreign-function-memory-api-jep-454\">Foreign Function &amp; Memory API \u2013 JEP 454<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Nach vielen Jahren der Entwicklung in <a href=\"https:\/\/openjdk.org\/projects\/panama\/\" target=\"_blank\" rel=\"noopener\">Project Panama<\/a> und nach insgesamt acht Incubator- und Preview-Versionen wird die Foreign Function &amp; Memory API in Java 22 durch <a href=\"https:\/\/openjdk.org\/jeps\/454\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 454<\/a> endlich finalisiert.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die Foreign Function &amp; Memory API (oder kurz: FFM API) erm\u00f6glicht es, aus Java heraus auf Code au\u00dferhalb der JVM (z. B. auf Funktionen in Bibliotheken, die in anderen Programmiersprachen implementiert wurden) sowie auf nativen Speicher (also Speicher, der nicht von der JVM im Heap verwaltet wird) zuzugreifen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die FFM API soll das extrem komplizierte, fehleranf\u00e4llige und langsame Java Native Interface (JNI) abl\u00f6sen und verspricht im direkten Vergleich 90 % weniger Implementierungsaufwand und die vier- bis f\u00fcnffache Performance.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Ich zeige dir hier an einem einfachen Beispiel, wie die API funktioniert \u2013 eine umfangreichere Einf\u00fchrung in das Thema findest du im <a href=\"\/de\/java\/foreign-function-memory-api\/\">Hauptartikel \u00fcber die Foreign Function &amp; Memory API<\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Der folgende Code ruft die <code>strlen()<\/code>-Funktion der Standard-C-Library auf, um die L\u00e4nge des Strings \u201eHappy Coding!\u201d zu bestimmen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-14\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">FFMTest22<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <span class=\"hljs-keyword\">throws<\/span> Throwable <\/span>{\n    <span class=\"hljs-comment\">\/\/ 1. Get a lookup object for commonly used libraries<\/span>\n    SymbolLookup stdlib = Linker.nativeLinker().defaultLookup();\n\n    <span class=\"hljs-comment\">\/\/ 2. Get a handle to the \"strlen\" function in the C standard library<\/span>\n    MethodHandle strlen =\n        Linker.nativeLinker()\n            .downcallHandle(\n                stdlib.find(<span class=\"hljs-string\">\"strlen\"<\/span>).orElseThrow(),\n                FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS));\n\n    <span class=\"hljs-comment\">\/\/ 3. Get a confined memory area (one that we can close explicitly)<\/span>\n    <span class=\"hljs-keyword\">try<\/span> (Arena offHeap = Arena.ofConfined()) {\n\n      <span class=\"hljs-comment\">\/\/ 4. Convert the Java String to a C string and store it in off-heap memory<\/span>\n      MemorySegment str = offHeap.allocateFrom(<span class=\"hljs-string\">\"Happy Coding!\"<\/span>);\n\n      <span class=\"hljs-comment\">\/\/ 5. Invoke the foreign function<\/span>\n      <span class=\"hljs-keyword\">long<\/span> len = (<span class=\"hljs-keyword\">long<\/span>) strlen.invoke(str);\n      System.out.println(<span class=\"hljs-string\">\"len = \"<\/span> + len);\n    }\n    <span class=\"hljs-comment\">\/\/ 6. Off-heap memory is deallocated at end of try-with-resources<\/span>\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-14\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Die einzelnen Schritte der Vorgehensweise sind durch Kommentare direkt im Quellcode beschrieben.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Der Code unterscheidet sich von der im <a href=\"\/de\/java\/java-21-features\/#Foreign_Function_Memory_API_Third_Preview_JEP_442\">Java-21-Artikel<\/a> vorgestellten Version in nur einem Detail: Die <code>Arena.allocateFrom(...)<\/code>-Methode hie\u00df zuvor <code>allocateUtf8String(...)<\/code>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Du kannst das Programm mit Java 22 wie folgt starten: <\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-15\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">$ java --enable-native-access=ALL-UNNAMED FFMTest22.java\nlen = 13<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-15\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Weiter will ich in die Details der FFM API an dieser Stelle nicht eingehen. Du findest eine ausf\u00fchrliche Beschreibung der API und all ihrer Komponenten im <a href=\"\/de\/java\/foreign-function-memory-api\/\">Hauptartikel \u00fcber die FFM API<\/a>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"locale-dependent-list-patterns\">Locale-Dependent List Patterns<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Mit der neuen Klasse <a href=\"https:\/\/docs.oracle.com\/en\/java\/javase\/22\/docs\/api\/java.base\/java\/text\/ListFormat.html\" target=\"_blank\" rel=\"noopener\">ListFormat<\/a> (\u2190 Link zur Dokumentation) lassen sich Listen als Aufz\u00e4hlung formatieren, so wie wir sie in Flie\u00dftext formulieren w\u00fcrden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Hier ist ein Beispiel:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-16\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">List&lt;String&gt; list = List.of(<span class=\"hljs-string\">\"Earth\"<\/span>, <span class=\"hljs-string\">\"Wind\"<\/span>, <span class=\"hljs-string\">\"Fire\"<\/span>);\nListFormat formatter = ListFormat.getInstance(Locale.GERMAN, Type.STANDARD, Style.FULL);\nSystem.out.println(formatter.format(list));<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-16\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Der Code gibt folgendes aus:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-17\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">Earth, Wind und Fire<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-17\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Wenn wir den <code>locale<\/code>-Parameter auf <code>Locale.US<\/code> \u00e4ndern, kommt folgendes heraus:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-18\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">Earth, Wind, and Fire<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-18\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Und die Einstellung <code>Locale.FRANCE<\/code> f\u00fchrt zu:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-19\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">Earth, Wind et Fire<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-19\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Neben <code>locale<\/code> hat die <code>ListFormat.getInstance(...)<\/code>-Methode noch zwei weitere Parameter:<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><code>type<\/code> \u2013 der Typ der Aufz\u00e4hlung \u2013 hier gibt es drei Varianten: <\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>STANDARD<\/code> f\u00fcr eine Auflistung mit \u201eund\u201d,<\/li>\n\n\n\n<li><code>OR<\/code> f\u00fcr eine Auflistung mit \u201eoder\u201d,<\/li>\n\n\n\n<li><code>UNIT<\/code> f\u00fcr eine Auflistung von Einheiten, entspricht je nach Locale einer Auflistung mit \u201eund\u201d oder einer mit nur Kommas.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\"><code>style<\/code> \u2013 der Stil der Aufz\u00e4hlung \u2013 auch hier gibt es drei Varianten:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>FULL<\/code> \u2013 die Bindew\u00f6rter wie \u201eund\u201d und \u201eoder\u201d werden ausgeschrieben.<\/li>\n\n\n\n<li><code>SHORT<\/code> \u2013 die Bindew\u00f6rter werden je nach Locale ausgeschrieben oder abgek\u00fcrzt.<\/li>\n\n\n\n<li><code>NARROW<\/code> \u2013 die Bindew\u00f6rter werden je nach Locale ausgeschrieben oder weggelassen, ggf. werden auch Kommas weggelassen.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">In der folgenden Tabelle siehst du alle Kombinationen f\u00fcr <code>Locale.GERMANY<\/code>:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-regular\"><table><tbody><tr><td><\/td><td><code>FULL<\/code><\/td><td><code>SHORT<\/code><\/td><td><code>NARROW<\/code><\/td><\/tr><tr><td><code>STANDARD<\/code><\/td><td>Earth, Wind und Fire<\/td><td>Earth, Wind und Fire<\/td><td>Earth, Wind und Fire<\/td><\/tr><tr><td><code>OR<\/code><\/td><td>Earth, Wind oder Fire<\/td><td>Earth, Wind oder Fire<\/td><td>Earth, Wind oder Fire<\/td><\/tr><tr><td><code>UNIT<\/code><\/td><td>Earth, Wind und Fire<\/td><td>Earth, Wind und Fire<\/td><td>Earth, Wind und Fire<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Wie du siehst, gibt es im deutschen keine Unterschiede zwischen den Typen <code>STANDARD<\/code> und <code>UNIT<\/code>, und der Stil spielt \u00fcberhaupt keine Rolle.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Schauen wir uns einmal das <code>Locale.US<\/code>-Format an:<\/p>\n\n\n\n<figure class=\"wp-block-table is-style-regular\"><table><tbody><tr><td><\/td><td><code>FULL<\/code><\/td><td><code>SHORT<\/code><\/td><td><code>NARROW<\/code><\/td><\/tr><tr><td><code>STANDARD<\/code><\/td><td>Earth, Wind, and Fire<\/td><td>Earth, Wind, &amp; Fire<\/td><td>Earth, Wind, Fire<\/td><\/tr><tr><td><code>OR<\/code><\/td><td>Earth, Wind, or Fire<\/td><td>Earth, Wind, or Fire<\/td><td>Earth, Wind, or Fire<\/td><\/tr><tr><td><code>UNIT<\/code><\/td><td>Earth, Wind, Fire<\/td><td>Earth, Wind, Fire<\/td><td>Earth Wind Fire<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">Hier lassen sich hingegen mehr Unterschiede ausmachen: Beim Typ UNIT wird vor dem letzten Element kein Verbindungswort eingef\u00fcgt, und das \u201eand\u201d wird beim Stil <code>SHORT<\/code> zu \u201e&amp;\u201d und f\u00e4llt beim Stil <code>NARROW<\/code> komplett weg.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die parameterlose Methode <code>ListFormat.getInstance()<\/code> liefert ein Listenformat f\u00fcr die Standard-Locale, den Typ <code>STANDARD<\/code> und den Stil <code>FULL<\/code>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr diese \u00c4nderung gibt es keinen JEP, sie ist im Bug-Tracker unter <a href=\"https:\/\/bugs.openjdk.org\/browse\/JDK-8041488\" target=\"_blank\" rel=\"noopener\">JDK-8041488<\/a> zu finden.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"neue-preview-features-in-java-22\">Neue Preview-Features in Java 22<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Java 22 bringt uns drei neue Features im Preview Stadium. Da sich Preview-Features noch \u00e4ndern k\u00f6nnen, solltest du sie nicht in Produktivcode einsetzen. Du musst sie sowohl im <code>javac<\/code>- als auch im <code>java<\/code>-Kommando explizit \u00fcber die VM-Optionen <code>--enable-preview --source 22<\/code> freischalten.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"statements-before-super-preview-jep-447\">Statements before super(\u2026) (Preview) \u2013 JEP 447<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Hast du dich auch schon mal ge\u00e4rgert, dass du vor dem Aufruf eines Super-Konstruktors mit <code>super(...)<\/code> oder vor dem Aufruf eines alternativen Konstruktors mit <code>this(...)<\/code> keinen anderen Code aufrufen darfst? <\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Musstest du auch schon mal ein Unget\u00fcm wie das folgende schreiben, nur um das Argument f\u00fcr einen Super-Konstruktor zu berechnen oder zu validieren?<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-20\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">Square<\/span> <span class=\"hljs-keyword\">extends<\/span> <span class=\"hljs-title\">Rectangle<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-title\">Square<\/span><span class=\"hljs-params\">(Color color, <span class=\"hljs-keyword\">int<\/span> area)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">this<\/span>(color, Math.sqrt(validateArea(area)));\n  }\n\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">private<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">double<\/span> <span class=\"hljs-title\">validateArea<\/span><span class=\"hljs-params\">(<span class=\"hljs-keyword\">int<\/span> area)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">if<\/span> (area &lt; <span class=\"hljs-number\">0<\/span>) <span class=\"hljs-keyword\">throw<\/span> <span class=\"hljs-keyword\">new<\/span> IllegalArgumentException();\n    <span class=\"hljs-keyword\">return<\/span> area;\n  }\n\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">private<\/span> <span class=\"hljs-title\">Square<\/span><span class=\"hljs-params\">(Color color, <span class=\"hljs-keyword\">double<\/span> sideLength)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">super<\/span>(color, sideLength, sideLength);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-20\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Es ist nicht leicht zu erkennen, was dieser Code tut, um warum er das auf so komplizierte Weise macht.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">W\u00e4re es nicht viel sch\u00f6ner, man k\u00f6nnte einfach folgendes schreiben?<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-21\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> class Square extends Rectangle\n  <span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-title\">Square<\/span><span class=\"hljs-params\">(Color color, <span class=\"hljs-keyword\">int<\/span> area)<\/span> <\/span>{\n    <span class=\"hljs-keyword\">if<\/span> (area &lt; <span class=\"hljs-number\">0<\/span>) <span class=\"hljs-keyword\">throw<\/span> <span class=\"hljs-keyword\">new<\/span> IllegalArgumentException();\n    <span class=\"hljs-keyword\">double<\/span> sideLength = Math.sqrt(area);\n    <span class=\"hljs-keyword\">super<\/span>(color, sideLength, sideLength);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-21\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Hier ist sofort ersichtlich, was der Konstruktor tut (selbst ohne die <code>Rectangle<\/code>-Elternklasse zu kennen):<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>Er validiert, dass <code>area<\/code> nicht negativ ist.<\/li>\n\n\n\n<li>Er berechnet die Seitenl\u00e4nge des Quadrats als Wurzel der Fl\u00e4che.<\/li>\n\n\n\n<li>Er ruft den Super-Konstruktor von <code>Rectangle<\/code> auf und \u00fcbergibt als Breite und H\u00f6he die Seitenl\u00e4nge des Quadrats. <\/li>\n<\/ol>\n\n\n\n<p class=\"wp-block-paragraph\">Doch bisher war das nicht m\u00f6glich. Bisher musste der Aufruf von <code>super(...)<\/code> das erste Statement in einem Konstruktor sein. Code f\u00fcr die Validierungen von Parametern und die Berechnung von Argumenten f\u00fcr die <code>super(...)<\/code>-Methode musste kompliziert in separate Methoden oder alternative Konstruktoren ausgelagert werden, wie im ersten Code-Beispiel.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Mit Java 22 (mit aktivierten Preview-Features) kannst du den Code nun so schreiben, wie im zweiten Beispiel: mit Validierungs- und Berechnungslogik <em>vor<\/em> dem Aufruf von <code>super(...)<\/code>!<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Das Preview-Feature \u201eStatements before super(\u2026)\u201d wird in <a href=\"https:\/\/openjdk.org\/jeps\/447\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 447<\/a> definiert.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Eine tiefergehende Betrachtung und einige Besonderheiten, die du beim Schreiben von Code vor <code>super(...)<\/code> oder <code>this(...)<\/code> beachten musst, findest du im Hauptartikel \u00fcber <a href=\"\/de\/java\/flexible-constructor-bodies\/\">Flexible Constructor Bodies<\/a> (wie das Feature ab <a href=\"\/de\/java\/java-23-features\/\">Java 23<\/a> hei\u00dft).<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"stream-gatherers-preview-jep-461\">Stream Gatherers (Preview) \u2013 JEP 461<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Seit Jahren st\u00f6\u00dft die begrenzte Zahl an intermedi\u00e4ren Stream-Operationen der Java-Stream-API auf Kritik. Neben den bestehenden Operationen <em>filter<\/em>, <em>map<\/em>, <em>flatMap<\/em>, <em>mapMulti<\/em>, <em>distinct<\/em>, <em>sorted<\/em>, <em>peak<\/em>, <em>limit<\/em>, <em>skip<\/em>, <em>takeWhile <\/em>und <em>dropWhile <\/em>w\u00fcnscht sich die Java-Community Methoden wie <em>window<\/em> und <em>fold<\/em> und zahlreiche mehr.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Doch anstatt all diese Methoden ins JDK zu integrieren, entschieden sich die JDK-Entwickler, stattdessen eine API zu entwickeln, die es sowohl den JDK-Entwicklern als auch der Java-Community erm\u00f6glicht, beliebige intermedi\u00e4re Stream-Operationen zu schreiben.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die neue API hei\u00dft \u201eStream Gatherers\u201c und wird durch <a href=\"https:\/\/openjdk.org\/jeps\/461\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 461<\/a> in Java 22 erstmals als Preview-Feature ver\u00f6ffentlicht.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Zusammen mit der API wird eine ganze Reihe vordefinierter Gatherer mitgeliefert, so zum Beispiel die gew\u00fcnschten Window- und Fold-Operationen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Mit der \u201eFixed Window\u201c-Operation z. B. kannst du Stream-Elemente in Listen vorgegebener Gr\u00f6\u00dfen gruppieren:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-22\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">List&lt;String&gt; words = List.of(<span class=\"hljs-string\">\"the\"<\/span>, <span class=\"hljs-string\">\"be\"<\/span>, <span class=\"hljs-string\">\"two\"<\/span>, <span class=\"hljs-string\">\"of\"<\/span>, <span class=\"hljs-string\">\"and\"<\/span>, <span class=\"hljs-string\">\"a\"<\/span>, <span class=\"hljs-string\">\"in\"<\/span>, <span class=\"hljs-string\">\"that\"<\/span>);\n\nList&lt;List&lt;String&gt;&gt; fixedWindows = words.stream()\n    .gather(Gatherers.windowFixed(<span class=\"hljs-number\">3<\/span>))\n    .toList();\n\nSystem.out.println(fixedWindows);\n<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-22\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Dieses kleine Beispielprogramm gibt folgendes aus:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-23\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">&#091;&#091;the, be, two], &#091;of, and, a], &#091;in, that]]\n<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-23\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Mit der \u201eSliding Window\u201c-Operation kannst du Stream-Elemente ebenfalls gruppieren, allerdings \u00fcberlappen die erzeugten Listen und sind um jeweils ein Element verschoben:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-24\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\">List&lt;Integer&gt; numbers = List.of(<span class=\"hljs-number\">1<\/span>, <span class=\"hljs-number\">2<\/span>, <span class=\"hljs-number\">3<\/span>, <span class=\"hljs-number\">4<\/span>, <span class=\"hljs-number\">5<\/span>);\n\nList&lt;List&lt;Integer&gt;&gt; slidingWindows = numbers.stream()\n    .gather(Gatherers.windowSliding(<span class=\"hljs-number\">3<\/span>))\n    .toList();\n\nSystem.out.println(slidingWindows);<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-24\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Dieses Programm gibt folgendes aus:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-25\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">&#091;&#091;1, 2, 3], &#091;2, 3, 4], &#091;3, 4, 5]]<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-25\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Welche weiteren vordefinierten Stream-Gatherer Java 22 bereith\u00e4lt und wie du solch einen Gatherer selbst implementierst, erf\u00e4hrst du im <a href=\"\/de\/java\/stream-gatherers\/\">Hauptartikel \u00fcber Stream Gatherer<\/a>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"class-file-api-preview-jep-457\">Class-File API (Preview) \u2013 JEP 457<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Die Java Class-File API ist eine Schnittstelle zum Lesen und Schreiben von <em>.class<\/em>-Dateien, also von kompiliertem Java-Bytecode. Die neue API soll das im JDK intensiv genutzte Bytecode-Manipulations-Framework <a href=\"https:\/\/asm.ow2.io\/\" target=\"_blank\" rel=\"noopener\">ASM<\/a> abl\u00f6sen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Der Grund f\u00fcr die Entwicklung einer eigenen API liegt darin, dass eine Library ben\u00f6tigt wird, die zum einen mit dem sechsmonatigen Ver\u00f6ffentlichungszyklus des JDK Schritt halten kann und zum anderen nicht immer eine Version hinterherhinkt. Denn erst wenn ein JDK ver\u00f6ffentlicht ist, kann ASM auf diese Version angepasst werden \u2013 die neue ASM-Version kann dann aber wiederum erst in der n\u00e4chsten JDK-Version eingesetzt werden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Da die meisten Java-Programmiererinnen und -Programmierer wahrscheinlich nie direkt mit der Class-File-API in Ber\u00fchrung kommen werden, werde ich sie an dieser Stelle nicht detailliert beschreiben.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Sollte die Class-File-API f\u00fcr dich von Interesse sein, findest du alle Einzelheiten in <a href=\"https:\/\/openjdk.org\/jeps\/457\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 457<\/a>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"wiedervorgelegte-preview-und-incubator-features\">Wiedervorgelegte Preview und Incubator-Features<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">F\u00fcnf Preview- und Incubator-Features werden in Java 22 wiedervorgelegt, drei davon ohne \u00c4nderungen gegen\u00fcber <a href=\"\/de\/java\/java-21-features\/\">Java 21<\/a>:<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"structured-concurrency-second-preview-jep-462\">Structured Concurrency (Second Preview) \u2013 JEP 462<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Structured Concurrency erm\u00f6glicht eine einfache Koordination von nebenl\u00e4ufigen Aufgaben und f\u00fchrt mit <code>StructuredTaskScope<\/code> eine Kontrollstruktur ein, die den Anfang und das Ende nebenl\u00e4ufiger Tasks klar definiert, eine saubere Fehlerbehandlung erm\u00f6glicht und Teilaufgaben, deren Ergebnisse nicht mehr ben\u00f6tigt werden, geordnet abbrechen kann.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">So l\u00e4sst sich z. B. sehr leicht eine <code>race()<\/code>-Methode implementieren, die zwei Tasks startet, das Ergebnis des zuerst beendeten Tasks zur\u00fcckliefert und den zweiten Task abbricht:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-26\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> &lt;R&gt; <span class=\"hljs-function\">R <span class=\"hljs-title\">race<\/span><span class=\"hljs-params\">(Callable&lt;R&gt; task1, Callable&lt;R&gt; task2)<\/span>\n    <span class=\"hljs-keyword\">throws<\/span> InterruptedException, ExecutionException <\/span>{\n  <span class=\"hljs-keyword\">try<\/span> (<span class=\"hljs-keyword\">var<\/span> scope = <span class=\"hljs-keyword\">new<\/span> StructuredTaskScope.ShutdownOnSuccess&lt;R&gt;()) {\n    scope.fork(task1);\n    scope.fork(task2);\n    scope.join();\n    <span class=\"hljs-keyword\">return<\/span> scope.result();\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-26\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Structured Concurrency wurde in <a href=\"\/de\/java\/java-21-features\/#Structured_Concurrency_Preview_JEP_453\">Java 21<\/a> als Preview-Feature vorgestellt. Eine ausf\u00fchrlichere Behandlung und zahlreiche weitere Beispiele findest du im <a href=\"\/de\/java\/structured-concurrency-structuredtaskscope\/\">Hauptartikel \u00fcber Structured Concurrency<\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Durch <a href=\"https:\/\/openjdk.org\/jeps\/462\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 462<\/a> geht dieses Feature in Java 22 ohne \u00c4nderungen in eine zweite Preview-Phase, um der Java-Community weitere Gelegenheit zum Testen und zur Einreichung von Feedback zu erm\u00f6glichen.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"scoped-values-second-preview-jep-464\">Scoped Values (Second Preview) \u2013 JEP 464<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Scoped Values erlauben es, einen oder mehrere Werte an eine oder mehrere Methoden zu \u00fcbergeben, ohne sie als explizite Parameter zu definieren und von einer Methode zur n\u00e4chsten weiterreichen zu m\u00fcssen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Das folgende Beispiel zeigt, wie ein Webserver den eingeloggten User als Scoped Value definiert und in dessen Scope den Request weiterverarbeitet:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-27\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">Server<\/span> <\/span>{\n  <span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">final<\/span> <span class=\"hljs-keyword\">static<\/span> ScopedValue&lt;User&gt; LOGGED_IN_USER = ScopedValue.newInstance();\n  . . .\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">private<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">serve<\/span><span class=\"hljs-params\">(Request request)<\/span> <\/span>{\n    . . .\n    User loggedInUser = authenticateUser(request);\n    ScopedValue.where(LOGGED_IN_USER, loggedInUser)\n               .run(() -&gt; restAdapter.processRequest(request));\n    . . .\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-27\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Nehmen wir an, der durch den Server aufgerufene REST-Adapter ruft einen Service auf und dieser Service wiederum ein Repository. In diesem Repository k\u00f6nnten wir dann z. B. wie folgt auf den eingeloggten User zugreifen:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-28\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">Repository<\/span> <\/span>{\n  . . .\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> Data <span class=\"hljs-title\">getData<\/span><span class=\"hljs-params\">(UUID id)<\/span> <\/span>{\n    Data data = findById(id);\n    User loggedInUser = Server.LOGGED_IN_USER.get();\n    <span class=\"hljs-keyword\">if<\/span> (loggedInUser.isAdmin()) {\n      enrichDataWithAdminInfos(data);\n    }\n    <span class=\"hljs-keyword\">return<\/span> data;\n  }\n  . . .\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-28\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Scoped Values wurden gemeinsam mit Structured Concurrency in <a href=\"\/de\/java\/java-21-features\/#Scoped_Values_Preview_JEP_446\">Java 21<\/a> als Preview-Feature eingef\u00fchrt. Eine ausf\u00fchrliche Einf\u00fchrung und einen Vergleich mit <code>ThreadLocal<\/code>-Variablen findest du im <a href=\"\/de\/java\/scoped-values\/\">Hauptartikel \u00fcber Scoped Values<\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Auch Scoped Values gehen in Java 22 ohne \u00c4nderungen in eine zweite Preview-Runde, spezifiziert durch <a href=\"https:\/\/openjdk.org\/jeps\/464\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 464<\/a>.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"string-templates-second-preview-jep-459\">String Templates (Second Preview) \u2013 JEP 459<\/h3>\n\n\n\n<div class=\"wp-block-uagb-info-box uagb-block-af9d0506 uagb-infobox__content-wrap  uagb-infobox-icon-left uagb-infobox-left uagb-infobox-stacked-mobile uagb-infobox-image-valign-top hc-infobox\"><div class=\"uagb-ifb-icon-wrap\"><svg xmlns=\"https:\/\/www.w3.org\/2000\/svg\" viewBox=\"0 0 512 512\"><path d=\"M256 0C114.6 0 0 114.6 0 256s114.6 256 256 256s256-114.6 256-256S397.4 0 256 0zM256 128c17.67 0 32 14.33 32 32c0 17.67-14.33 32-32 32S224 177.7 224 160C224 142.3 238.3 128 256 128zM296 384h-80C202.8 384 192 373.3 192 360s10.75-24 24-24h16v-64H224c-13.25 0-24-10.75-24-24S210.8 224 224 224h32c13.25 0 24 10.75 24 24v88h16c13.25 0 24 10.75 24 24S309.3 384 296 384z\"><\/path><\/svg><\/div><div class=\"uagb-ifb-content\"><div class=\"uagb-ifb-title-wrap\"><\/div><p class=\"uagb-ifb-desc\"><strong>Breaking News: <\/strong>Am 05.04.2024 hat Gavin Bierman <a href=\"https:\/\/mail.openjdk.org\/pipermail\/amber-spec-experts\/2024-April\/004106.html\" target=\"_blank\" rel=\"noopener\">bekanntgegeben, dass String Templates in der hier beschriebenen Form <em>nicht<\/em> ver\u00f6ffentlicht werden<\/a>. Es besteht Einigkeit dar\u00fcber, dass das Design ge\u00e4ndert werden soll, es besteht allerdings kein Konsens dar\u00fcber, <em>wie<\/em> es ge\u00e4ndert werden soll. Die Sprachentwickler wollen sich nun Zeit nehmen, das Design zu \u00fcberarbeiten. String Templates werden daher in <a href=\"\/de\/java\/java-23-features\/\">Java 23<\/a> nicht weiter enthalten sein, auch nicht mit <code>--enable-preview<\/code>.<\/p><\/div><\/div>\n\n\n\n<p class=\"wp-block-paragraph\">Mit String Templates k\u00f6nnen Strings zur Laufzeit durch sogenannte String-Interpolation anhand von Variablen und berechneten Werten zusammengesetzt werden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-29\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">int<\/span> a = ...;\n<span class=\"hljs-keyword\">int<\/span> b = ...;\n\nString interpolated = STR.<span class=\"hljs-string\">\"\\{a} times \\{b} = \\{Math.multiplyExact(a, b)}\"<\/span>;<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-29\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Zur Laufzeit werden hier folgende Ersetzungen vorgenommen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>\\{a}<\/code> wird durch den Wert der Variablen <code>a<\/code> ersetzt.<\/li>\n\n\n\n<li><code>\\{b}<\/code> wird durch den Wert der Variablen <code>b<\/code> ersetzt.<\/li>\n\n\n\n<li><code>\\{Math.multiplyExact(a, b)}<\/code> wird durch das Ergebnis des Aufrufes der Methode <code>Math.multiplyExact(a, b)<\/code> ersetzt.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">String Templates wurden in <a href=\"\/de\/java\/java-21-features\/#String_Templates_Preview_JEP_430\">Java 21<\/a> als Preview-Feature eingef\u00fchrt. Eine ausf\u00fchrlichere Beschreibung findest du im <a href=\"\/de\/java\/string-templates\/\">Hauptartikel \u00fcber String Templates<\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Und auch String Templates gehen \u2013 durch <a href=\"https:\/\/openjdk.org\/jeps\/459\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 459<\/a> spezifiziert \u2013 als drittes Preview-Feature in Java 22 ohne \u00c4nderungen in eine zweite Preview-Runde.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"implicitly-declared-classes-and-instance-main-methods-second-preview-jep-463\">Implicitly Declared Classes and Instance Main Methods (Second Preview) \u2013 JEP 463<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Java-Anf\u00e4ngerinnen und -Anf\u00e4nger beginnen oft mit sehr einfachen Programmen, wie z. B. dem folgenden:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-30\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">HelloWorld<\/span> <\/span>{\n  <span class=\"hljs-function\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">(String&#091;] args)<\/span> <\/span>{\n    System.out.println(<span class=\"hljs-string\">\"Hello world!\"<\/span>);\n  }\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-30\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr Java-Neulinge kann dieses Beispiel trotz seiner Einfachheit extrem verwirrend sein, denn sie sind in der Regel noch nicht vertraut mit Konzepten wie Sichtbarkeitsmodifikatoren, Klassenstrukturen und statischen Methoden. Der ungenutzte <code>args<\/code>-Parameter und das schwergewichtige <code>System.out.println(...)<\/code> tun ihr \u00dcbriges.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">W\u00e4re es nicht viel einfacher, wenn man all diese \u00fcberfl\u00fcssigen Elemente entfernen k\u00f6nnte? Zum Beispiel so:<\/p>\n\n\n\n<figure class=\"wp-block-image size-full_800\"><img decoding=\"async\" width=\"800\" height=\"152\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-800x152.png\" alt=\"java 22 implicitly declared classes and instance main methods\" class=\"wp-image-35734\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-800x152.png 800w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-224x43.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-336x64.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-504x96.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-672x128.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-400x76.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-600x114.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-944x179.png 944w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods-1200x228.png 1200w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/06\/java21-unnamed-classes-and-instance-main-methods.png 1600w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\"><a href=\"https:\/\/openjdk.org\/jeps\/463\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 463<\/a> macht dies m\u00f6glich. Der folgende, nach der L\u00f6schaktion verbleibende Code ist somit ein g\u00fcltiges und vollst\u00e4ndiges Java-Programm:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-31\" data-shcb-language-name=\"Java\" data-shcb-language-slug=\"java\"><span><code class=\"hljs language-java\"><span class=\"hljs-function\"><span class=\"hljs-keyword\">void<\/span> <span class=\"hljs-title\">main<\/span><span class=\"hljs-params\">()<\/span> <\/span>{\n  System.out.println(<span class=\"hljs-string\">\"Hello world!\"<\/span>);\n}<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-31\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Java<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">java<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Damit k\u00f6nnen Anf\u00e4nger langsam als bisher an die Sprache herangef\u00fchrt werden. Konzepte, die f\u00fcr gr\u00f6\u00dfere Programme relevant werden, wie Klassen, die Unterscheidung in statische und Instanzmethoden, Sichtbarkeitsmodifikatoren wie <code>public<\/code>, <code>protected<\/code> und <code>private<\/code> sowie grobgranulare Strukturen wie Pakete und Module k\u00f6nnen so nach und nach gelehrt werden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Beachte, dass dieses Feature in Java 22 noch im Preview-Modus ist. Wenn du das Programm unter <em>HelloWorld.java<\/em> speicherst, kannst du es wie folgt starten:<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-32\" data-shcb-language-name=\"Klartext\" data-shcb-language-slug=\"plaintext\"><span><code class=\"hljs language-plaintext\">$ java --enable-preview --source 22 HelloWorld.java\nNote: Hello.java uses preview features of Java SE 22.\nNote: Recompile with -Xlint:preview for details.\nHello world!<\/code><\/span><small class=\"shcb-language\" id=\"shcb-language-32\"><span class=\"shcb-language__label\">Code-Sprache:<\/span> <span class=\"shcb-language__name\">Klartext<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">plaintext<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"wp-block-paragraph\">Mehr Details \u00fcber die Bestandteile dieses Features \u2013 einfache Quelldateien, implizit deklarierte Klassen und Instanz-Main-Methoden \u2013 kannst du im Abschnitt&nbsp;<a href=\"https:\/\/www.happycoders.eu\/de\/java\/main-methode\/#compact-source-files-and-instance-main-methods\">Compact Source Files and Instance Main Methods<\/a>&nbsp;(so wird das Feature ab <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-25-features\/\">Java 25<\/a> hei\u00dfen) des Artikels \u00fcber die Java-<em>main<\/em>-Methode nachlesen.<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">R\u00fcckblick<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">Das Feature wurde in Java 21 bereits unter dem Namen <a href=\"\/de\/java\/java-21-features\/#Unnamed_Classes_and_Instance_Main_Methods_Preview_JEP_445\">Unnamed Classes and Instance Main Methods<\/a> vorgestellt. Das Konzept der unbenannten Klasse wurde f\u00fcr Java 22 in das deutlich simplere Konzept der implizit deklarierten Klasse abge\u00e4ndert, und das Launch-Protokoll der Main-Methode wurde vereinfacht.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"vector-api-seventh-incubator-jep-460\">Vector API (Seventh Incubator) \u2013 JEP 460<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Die seit nunmehr \u00fcber drei Jahren entwickelte neue Vector API geht mit <a href=\"https:\/\/openjdk.org\/jeps\/460\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 460<\/a> in die siebte Inkubator-Runde.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die Vector API erm\u00f6glicht es, Vektor-Operationen durchzuf\u00fchren, wie z. B. die folgende Vektor-Addition:<\/p>\n\n\n<div class=\"wp-block-image\">\n<figure class=\"aligncenter size-half_400\"><img decoding=\"async\" width=\"400\" height=\"91\" src=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2021\/12\/java-vector-addition-400x91.png\" alt=\"java vector addition\" class=\"wp-image-25531\" srcset=\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2021\/12\/java-vector-addition-400x91.png 400w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2021\/12\/java-vector-addition-224x51.png 224w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2021\/12\/java-vector-addition-336x76.png 336w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2021\/12\/java-vector-addition-504x115.png 504w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2021\/12\/java-vector-addition-672x153.png 672w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2021\/12\/java-vector-addition-600x137.png 600w, https:\/\/www.happycoders.eu\/wp-content\/uploads\/2021\/12\/java-vector-addition.png 800w\" sizes=\"(max-width: 400px) 100vw, 400px\" \/><figcaption class=\"wp-element-caption\">Beispiel einer Vektoraddition<\/figcaption><\/figure>\n<\/div>\n\n\n<p class=\"wp-block-paragraph\">Das besondere dabei ist, dass die JVM diese Berechnungen auf m\u00f6glichst effiziente Art auf die Vektor-Operationen moderner CPUs abbildet, so dass solche Berechnungen (bis zu einer bestimmten Vektorgr\u00f6\u00dfe) in einem einzigen CPU-Zyklus ausgef\u00fchrt werden k\u00f6nnen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Da sich das Feature noch immer im Incubator-Stadium befindet, also wesentliche \u00c4nderungen nicht ausgeschlossen sind, werde ich in diesem Artikel noch nicht weiter auf die Details eingehen. Ich werde die neue API detailliert vorstellen, sobald sie das Preview-Stadium erreicht.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"deprecations-und-loeschungen\">Deprecations und L\u00f6schungen<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Auch in Java 22 wurden wieder einige Funktionen als \u201edeprecated\u201d markiert bzw. zuvor als \u201edeprecated for removal\u201d markierte Funktionen aus dem JDK entfernt.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"thread-countstackframes-has-been-removed\">Thread.countStackFrames has been removed<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Die Methode <code>Thread.countStackFrames()<\/code> wurde bereits in Java 1.2 im Jahr 1998 als \u201edeprecated\u201d markiert, in Java 9 wurde sie als \u201edeprecated for removal\u201d markiert, und seit Java 14 wirft sie eine <code>UnsupportedOperationException<\/code>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In Java 22 wird die Methode nun entfernt.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Zur Untersuchung des aktuellen Stacks wurde als Alternative bereits in Java 9 die <a href=\"https:\/\/docs.oracle.com\/en\/java\/javase\/21\/docs\/api\/java.base\/java\/lang\/StackWalker.html\" target=\"_blank\" rel=\"noopener\">StackWalker-API<\/a> eingef\u00fchrt.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr diese \u00c4nderung gibt es keinen JEP, sie ist im Bug-Tracker unter <a href=\"https:\/\/bugs.openjdk.org\/browse\/JDK-8309196\" target=\"_blank\" rel=\"noopener\">JDK-8309196<\/a> zu finden.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"the-old-core-reflection-implementation-has-been-removed\">The Old Core Reflection Implementation Has Been Removed<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">In Java 18 wurde der <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-18-features\/#Reimplement_Core_Reflection_with_Method_Handles\">Core Reflection Mechanismus auf Basis von Method Handles neu implementiert<\/a>. Die alte Funktionalit\u00e4t konnte allerdings bisher \u00fcber die VM-Option <nobr><code>-Djdk.reflect.useDirectMethodHandle=false<\/code><\/nobr> wieder aktiviert werden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In Java 22 wird die alte Funktionalit\u00e4t komplett entfernt, und die o. g. VM-Option wird ignoriert.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr diese \u00c4nderung gibt es keinen JEP, sie ist im Bug-Tracker unter <a href=\"https:\/\/bugs.openjdk.org\/browse\/JDK-8305104\" target=\"_blank\" rel=\"noopener\">JDK-8305104<\/a> registriert.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"deprecations-und-loeschungen-in-sun-misc-unsafe\">Deprecations und L\u00f6schungen in sun.misc.Unsafe<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Diese Klasse <code>sun.misc.Unsafe<\/code> stellt Low-Level-Funktionalit\u00e4ten zur Verf\u00fcgung, die eigentlich nur von der Java-Kernbibliothek und nicht von anderen Java-Programmen genutzt werden sollen. Das hat allerdings viele Java-Entwickler nicht davon abgehalten, <code>Unsafe<\/code> dennoch zu benutzen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr viele Methoden in <code>Unsafe<\/code> wurden im Laufe der Zeit \u00f6ffentliche APIs im JDK zur Verf\u00fcgung gestellt. Diese Methoden werden zun\u00e4chst als \u201edeprecated\u201d markiert, dann als \u201edeprecated for removal\u201d, und schlie\u00dflich werden sie komplett entfernt.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">In Java 22 sind folgende Methoden von der Aufr\u00e4umaktion betroffen:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><code>Unsafe.park()<\/code> und <code>unpark()<\/code> wurden in Java 5 durch <code>java.util.concurrent.LockSupport.park()<\/code> und <code>unpark()<\/code> ersetzt und werden in Java 22 als \u201edeprecated for removal\u201d markiert.<\/li>\n\n\n\n<li><code>Unsafe.getLoadAverage()<\/code> wurde in Java 6 durch <code>java.lang.management.OperatingSystemMXBean.getSystemLoadAverage()<\/code> ersetzt und wird nun ebenfalls als \u201edeprecated for removal\u201d markiert.<\/li>\n\n\n\n<li><code>Unsafe.loadFence()<\/code>, <code>storeFence()<\/code> und <code>fullFence()<\/code> wurden in Java 9 durch gleichnamige Methoden in <code>java.lang.invoke.VarHandle<\/code> ersetzt und werden ebenfalls als \u201edeprecated for removal\u201d markiert.<\/li>\n\n\n\n<li><code>Unsafe.shouldBeInitialized()<\/code> und <code>ensureClassInitialized()<\/code> wurden in Java 15 durch <code>java.lang.invoke.MethodHandles.Lookup.ensureInitialized()<\/code> ersetzt und in derselben Java-Version als \u201edeprecated for removal\u201d markiert. Die Methoden werden in Java 22 entfernt.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">F\u00fcr diese \u00c4nderungen gibt es keinen JEP, sie sind im Bug-Tracker unter <a href=\"https:\/\/bugs.openjdk.org\/browse\/JDK-8315938\" target=\"_blank\" rel=\"noopener\">JDK-8315938<\/a> und <a href=\"https:\/\/bugs.openjdk.org\/browse\/JDK-8316160\" target=\"_blank\" rel=\"noopener\">JDK-8316160<\/a> zu finden.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"sonstige-aenderungen-in-java-22\">Sonstige \u00c4nderungen in Java 22<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">In diesem Abschnitt findest du einige \u00c4nderungen, mit denen du in der t\u00e4glichen Arbeit mit Java 22 eher nicht in Ber\u00fchrung kommen wirst. Es ist dennoch gut, \u00fcber diese \u00c4nderungen Bescheid zu wissen.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"region-pinning-for-g1-jep-423\">Region Pinning for G1 \u2013 JEP 423<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Bei der Arbeit mit JNI (was langfristig durch die in Java 22 finalisierte <a href=\"#Foreign_Function_Memory_API_JEP_454\">Foreign Function &amp; Memory API<\/a> abgel\u00f6st werden soll), verwendet man ggf. Methoden, die Zeiger auf die Speicheradresse eines Java-Objekts zur\u00fcckgeben und dann wieder freigeben. Ein Beispiel sind die Funktionen <a href=\"https:\/\/docs.oracle.com\/en\/java\/javase\/21\/docs\/specs\/jni\/functions.html#getstringcritical-releasestringcritical\" target=\"_blank\" rel=\"noopener\"><em>GetStringCritical<\/em> und <em>ReleaseStringCritical<\/em><\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Solange solch ein Zeiger noch nicht durch die entsprechende Release-Methode wieder freigegeben wurde, darf der Garbage Collector das Objekt nicht im Speicher verschieben, da dies den Zeiger ung\u00fcltig machen w\u00fcrde.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wenn ein Garbage Collector sogenanntes \u201ePinning\u201d unterst\u00fctzt, kann die JVM ihn anweisen, solch ein Objekt anzupinnen, was bedeutet, dass der Garbage Collector es nicht verschieben darf. <\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Wenn der Garbage Collector dieses Pinning jedoch nicht unterst\u00fctzt, bleibt der JVM nichts anderes \u00fcbrig, als die Garbage Collection komplett zu pausieren, sobald irgendeine <em>Get*Critical<\/em>-Methode aufgerufen wurde und sie erst dann wieder zu aktivieren, wenn alle entsprechenden <em>Release*Critical<\/em>-Methoden aufgerufen wurden. Je nach Verhalten einer Anwendung kann das drastische Konsequenzen auf den Speicherverbrauch und die Performance haben.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Der G1-Garbage-Collector hat bisher Pinning nicht unterst\u00fctzt. Mit <a href=\"https:\/\/openjdk.org\/jeps\/423\" target=\"_blank\" rel=\"noopener\">JDK Enhancement Proposal 423<\/a> wird er um die Pinning-Funktionalit\u00e4t erweitert, d. h. ab Java 22 braucht der Garbage Collector nicht mehr pausiert zu werden.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"support-fuer-unicode-15-1\">Support f\u00fcr Unicode 15.1<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">In Java 22 wird die Unicode-Unterst\u00fctzung auf <a href=\"https:\/\/unicode.org\/versions\/Unicode15.1.0\/\" target=\"_blank\" rel=\"noopener\">Unicode-Version 15.1<\/a> angehoben, die den Umfang des Zeichensatzes um 627 haupts\u00e4chlich chinesische Symbole auf insgesamt 149.813 Zeichen erh\u00f6ht.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Relevant ist das f\u00fcr Klassen wie String und Character, die mit den neuen Zeichen umgehen k\u00f6nnen m\u00fcssen. Ein Beispiel daf\u00fcr findest du im Artikel zu <a href=\"\/de\/java\/java-11-features\/#Unicode_10\">Java 11<\/a>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><em>(F\u00fcr diese \u00c4nderung gibt es keinen JEP, sie ist im Bug-Tracker unter <a href=\"https:\/\/bugs.openjdk.org\/browse\/JDK-8296246\" target=\"_blank\" rel=\"noopener\">JDK-8296246<\/a> registriert.)<\/em><\/p>\n\n\n\n<h3 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"make-lockingmode-a-product-flag\">Make LockingMode a product flag<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">Die in <a href=\"https:\/\/www.happycoders.eu\/de\/java\/java-21-features\/#Add_Experimental_-XXLockingMode_Flag\">Java 21<\/a> eingef\u00fchrte VM-Option <code>-XX:LockingMode<\/code> wird von einer experimentellen zu einer produktiven Option bef\u00f6rdert, d. h. sie muss nicht mehr mit <code>-XX:+UnlockExperimentalVMOptions<\/code> kombiniert werden.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><em>(F\u00fcr diese \u00c4nderung gibt es keinen JEP, sie ist im Bug-Tracker unter <a href=\"https:\/\/bugs.openjdk.org\/browse\/JDK-8315061\" target=\"_blank\" rel=\"noopener\">JDK-8315061<\/a> registriert.)<\/em><\/p>\n\n\n\n<h3 class=\"wp-block-heading\" id=\"vollstaendige-liste-aller-aenderungen-in-java-21\">Vollst\u00e4ndige Liste aller \u00c4nderungen in Java 22<\/h3>\n\n\n\n<p class=\"wp-block-paragraph\">In diesem Artikel hast du alle Java Enhancement Proposals kennengelernt, die in Java 22 umgesetzt wurden, sowie eine Auswahl weiterer \u00c4nderungen aus dem Bug-Tracker. Alle weiteren \u00c4nderungen findest du in den offiziellen <a href=\"https:\/\/www.oracle.com\/java\/technologies\/javase\/22all-relnotes.html\" target=\"_blank\" rel=\"noreferrer noopener\">Java 22 Release Notes<\/a>.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\" class=\"wp-block-heading\" id=\"fazit\">Fazit<\/h2>\n\n\n\n<p class=\"wp-block-paragraph\">Die Fanfaren des Java-21-Launches sind noch zu h\u00f6ren, da wartet bereits Java 22 mit beeindruckenden Features auf:<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><em>Unbenannte Variablen und Patterns<\/em> und <em>Statements before super<\/em> (letzteres noch in der Preview-Phase) werden Java-Code in Zukunft noch ausdrucksst\u00e4rker machen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Mit <em>Stream Gatherers<\/em> k\u00f6nnen wir endlich beliebige intermedi\u00e4re Stream-Operationen schreiben, so wie wir mit Kollektoren auch schon immer terminale Operationen schreiben konnten.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Mit <em>Launch Multi-File Source-Code Programs<\/em> k\u00f6nnen wir Programme, die aus nur einer Datei bestehen, endlich sauber erweitern, ohne auf den Komfort des Startens ohne explizites Kompilieren verzichten zu m\u00fcssen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Die Foreign <em>Function &amp; Memory API<\/em> ist endlich finalisiert und f\u00fcr den produktiven Einsatz bereit.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><em>Structured Concurrency<\/em>, <em>Scoped Values<\/em>, <em>String Templates<\/em> und <em>Unnamed Classes and Instance Main Methods<\/em> gehen in eine zweite Preview-Runde.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Diverse sonstige \u00c4nderungen runden wie immer das Release ab. Das aktuelle Java-22-Release kannst du <a href=\"https:\/\/jdk.java.net\/22\/\" target=\"_blank\" rel=\"noopener\">hier<\/a> herunterladen.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Auf welches Java-22-Feature freust du dich am meisten? Welches Feature vermisst du? Lasse es mich gerne \u00fcber die Kommentarfunktion wissen!<\/p>\n<aside><p>Wenn dir der Artikel weitergeholfen hat, w\u00fcrde ich mich sehr \u00fcber eine positive Bewertung auf meinem <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">ProvenExpert-Profil<\/a> freuen. Dein Feedback hilft mir, meine Inhalte weiter zu verbessern und motiviert mich, neue informative Artikel zu schreiben.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"https:\/\/www.provenexpert.com\/de-de\/sven-woltmann-happycoders-eu\/7smk\/\" target=\"_blank\" rel=\"noopener\">Bewertung abgeben<\/a><\/p>\r\n                        <p>Du m\u00f6chtest \u00fcber alle neuen Java-Features auf dem Laufenden sein? Dann <a href=\"#\" data-formkit-toggle=\"d8ee997126\">klicke hier<\/a>, um dich f\u00fcr den HappyCoders-Newsletter anzumelden.<\/p>\r\n                        <p>\ud83d\udc49 <a href=\"#\" data-formkit-toggle=\"d8ee997126\">Newsletter-Anmeldung<\/a><\/p><\/aside>","protected":false},"excerpt":{"rendered":"<p>Alle neuen Java 22-Funktionen mit Beispielen: Unnamed Variables &#038; Patterns, Stream Gatherers, Foreign Function &#038; Memory API, Launch Multi-File Source-Code Programs ... und mehr!<\/p>\n","protected":false},"author":1,"featured_media":39241,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_seopress_titles_title":"","_seopress_titles_desc":"Alle neuen Java 22-Funktionen mit Beispielen: Unnamed Variables & Patterns, Stream Gatherers, Foreign Function & Memory API ... und mehr!","_seopress_robots_index":"","_seopress_robots_follow":"","_seopress_robots_imageindex":"","_seopress_robots_snippet":"","_seopress_robots_primary_cat":"","_seopress_robots_breadcrumbs":"","_seopress_robots_freeze_modified_date":"","_seopress_robots_custom_modified_date":"","_seopress_robots_canonical":"","_seopress_social_fb_title":"","_seopress_social_fb_desc":"","_seopress_social_fb_img":"","_seopress_social_fb_img_attachment_id":0,"_seopress_social_fb_img_width":0,"_seopress_social_fb_img_height":0,"_seopress_social_twitter_title":"","_seopress_social_twitter_desc":"","_seopress_social_twitter_img":"","_seopress_social_twitter_img_attachment_id":0,"_seopress_social_twitter_img_width":0,"_seopress_social_twitter_img_height":0,"_seopress_redirections_value":"","_seopress_redirections_enabled":"","_seopress_redirections_enabled_regex":"","_seopress_redirections_logged_status":"","_seopress_redirections_param":"","_seopress_redirections_type":0,"_seopress_analysis_target_kw":"java-22-features,java-22","_seopress_news_disabled":"","_seopress_video_disabled":"","_seopress_video":[],"_seopress_pro_schemas_manual":[],"_seopress_pro_rich_snippets_disable_all":"","_seopress_pro_rich_snippets_disable":[],"_seopress_pro_schemas":[],"_uag_custom_page_level_css":"","_wp_convertkit_post_meta":{"form":"-1","landing_page":"","tag":"0","restrict_content":"0"},"_metis_text_type":"standard","_metis_text_length":31471,"_post_count":0,"footnotes":""},"categories":[64],"tags":[176],"class_list":["post-38619","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-versionen"],"uagb_featured_image_src":{"full":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2.jpg",1770,986,false],"thumbnail":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2.jpg",150,84,false],"medium":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2.jpg",300,167,false],"medium_large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2.jpg",768,428,false],"large":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2.jpg",1024,570,false],"feature_thumb_224":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-224x125.jpg",224,125,true],"feature_thumb_336":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-336x187.jpg",336,187,true],"feature_thumb_504":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-504x281.jpg",504,281,true],"feature_thumb_672":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-672x374.jpg",672,374,true],"half_400":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-400x223.jpg",400,223,true],"half_600":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-600x334.jpg",600,334,true],"full_800":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-800x446.jpg",800,446,true],"full_944":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-944x526.jpg",944,526,true],"full_1200":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-1200x668.jpg",1200,668,true],"wide_1180":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-1180x490.jpg",1180,490,true],"wide_1770":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2-1770x735.jpg",1770,735,true],"1536x1536":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2.jpg",1536,856,false],"2048x2048":["https:\/\/www.happycoders.eu\/wp-content\/uploads\/2023\/12\/java-22-features.v2.jpg",1770,986,false]},"uagb_author_info":{"display_name":"Sven Woltmann","author_link":"https:\/\/www.happycoders.eu\/de\/author\/sven\/"},"uagb_comment_info":1,"uagb_excerpt":"Alle neuen Java 22-Funktionen mit Beispielen: Unnamed Variables & Patterns, Stream Gatherers, Foreign Function & Memory API, Launch Multi-File Source-Code Programs ... und mehr!","public_identification_id":"1a1bafb250914b82997e8267513aa7ab","private_identification_id":"751aec36be704e82829197c09b27c689","_links":{"self":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/38619","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/comments?post=38619"}],"version-history":[{"count":10,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/38619\/revisions"}],"predecessor-version":[{"id":52397,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/posts\/38619\/revisions\/52397"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media\/39241"}],"wp:attachment":[{"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/media?parent=38619"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/categories?post=38619"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.happycoders.eu\/de\/wp-json\/wp\/v2\/tags?post=38619"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}