{"id":33905,"date":"2023-03-21T09:00:00","date_gmt":"2023-03-21T08:00:00","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=33905"},"modified":"2025-11-29T19:30:18","modified_gmt":"2025-11-29T18:30:18","slug":"java-20-features","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/java-20-features\/","title":{"rendered":"Java 20 Features (mit Beispielen)"},"content":{"rendered":"\n

Java 20 wurde am 21. M\u00e4rz 2023 ver\u00f6ffentlicht. Du kannst es hier<\/a> herunterladen.<\/p>\n\n\n\n

Nachdem wir in Java 19<\/a> mit virtuellen Threads<\/a> eine der gr\u00f6\u00dften Erweiterungen der Java-Geschichte ausprobieren durften, f\u00e4llt das Java-20-Release wieder etwas kleiner aus.<\/p>\n\n\n\n

Die interessanteste Neuerung nennt sich \"Scoped Values\"<\/a> und soll in zahlreichen Einsatzzwecken die mit diversen Nachteilen behafteten Thread-Local-Variablen ersetzen. <\/p>\n\n\n\n

Die restlichen f\u00fcnf der sechs in Java 20 ver\u00f6ffentlichten JEPs sind Wiedervorlagen bereits bekannter Incubator- und Preview-Features.<\/p>\n\n\n\n

Ich verwende wie immer ausschlie\u00dflich die englischen Bezeichnungen der JEPs.<\/p>\n\n\n\n\n\n

Preview- und Incubator-Features<\/h2>\n\n\n\n

Bei allen sechs JDK Enhancement Proposals (JEPs), die es in das Java-20-Release geschafft haben, handelt es sich um Incubator- bzw. Preview-Features. Das sind noch nicht fertiggestellte Features, die explizit (mit --enable-preview<\/code> bei den java<\/code> und javac<\/code> Kommandos) aktiviert werden m\u00fcssen, um sie testen zu k\u00f6nnen.<\/p>\n\n\n\n

Scoped Values (Incubator) \u2013 JEP 429<\/h3>\n\n\n\n

Scoped Values \u2013 genau wie virtuelle Threads<\/a> in Project Loom<\/a> entwickelt \u2013 sind eine moderne und insbesondere mit virtuellen Threads gut kombinierbare Alternative zu Thread Locals. Sie erm\u00f6glichen es, einen Wert f\u00fcr einen begrenzten Zeitraum so zu speichern, dass nur derjenige Thread den Wert lesen kann, der ihn geschrieben hat.<\/p>\n\n\n\n

Mit dem JDK Enhancement Proposal 429<\/a> werden Scoped Values in Java 20 erstmals im Incubator-Stadium vorgestellt.<\/p>\n\n\n\n

Wie Scoped Values genau funktionieren und warum sie gegen\u00fcber Thread Locals vorzuziehen sind, erf\u00e4hrst du im Hauptartikel \u00fcber Scoped Values<\/a>.<\/p>\n\n\n\n

Record Patterns (Second Preview) \u2013 JEP 432<\/h3>\n\n\n\n

Record Patterns wurden erstmals in Java 19<\/a> vorgestellt. Ein Record Pattern kann mit instanceof<\/code> oder switch<\/code> verwendet werden, um ohne Cast und Aufruf von Zugriffsmethoden auf die Felder eines Records zuzugreifen. <\/p>\n\n\n\n

Hier ein einfacher Beispiel-Record:<\/p>\n\n\n

public<\/span> record Position<\/span>(int<\/span> x, int<\/span> y)<\/span> <\/span>{}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Mittels Record Pattern k\u00f6nnen wir nun einen instanceof<\/code>-Ausdruck wie folgt schreiben:<\/p>\n\n\n
Object object = ...\n\nif<\/span> (object instanceof<\/span> Position<\/span>(int<\/span> x, int<\/span> y)<\/span>) <\/span>{\n  System.out.println(\"object is a position, x = \"<\/span> + x + \", y = \"<\/span> + y);\n} <\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Wir k\u00f6nnen somit \u2013 sofern object<\/code> vom Typ Position<\/code> ist \u2013 direkt auf dessen x- und y-Werte zugreifen.<\/p>\n\n\n\n
Das gleiche funktioniert in einem switch-Ausdruck:<\/p>\n\n\n
Object object = ...\n\nswitch<\/span> (object) {\n  case<\/span> Position<\/span>(int<\/span> x, int<\/span> y)<\/span> \n      -> System.out.println<\/span>(\"object is a position, x = \"<\/span> + x + \", y = \"<\/span> + y)<\/span><\/span>;\n\n  \/\/ other cases ...<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Inferenz von Typargumenten generischer Record Patterns<\/h4>\n\n\n\n
Um diese \u00c4nderung zu erkl\u00e4ren, brauchen wir ein komplexeres Beispiel.<\/p>\n\n\n\n
Gegeben seien ein generisches Interface Multi<T><\/code> und zwei implementierende Records, Tuple<T><\/code> und Triple<T><\/code>, die zwei bzw. drei Werte des Typs T<\/code> enthalten:<\/p>\n\n\n
interface<\/span> Multi<\/span><T<\/span>> <\/span>{}\n\nrecord Tuple<T>(T t1, T t2) implements Multi<T> {}\n\nrecord Triple<T>(T t1, T t2, T t3) implements Multi<T> {}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Mit folgendem Code k\u00f6nnen wir pr\u00fcfen, um welche konkrete Implementierung es sich bei einem gegebenen Multi<\/code>-Objekt handelt:<\/p>\n\n\n
Multi<String> multi = ...\n\nif<\/span> (multi instanceof<\/span> Tuple<String>(var<\/span> s1, var<\/span> s2)) {\n  System.out.println(\"Tuple: \"<\/span> + s1 + \", \"<\/span> + s2);\n} else<\/span> if<\/span> (multi instanceof<\/span> Triple<String>(var<\/span> s1, var<\/span> s2, var<\/span> s3)) {\n  System.out.println(\"Triple: \"<\/span> + s1 + \", \"<\/span> + s2 + \", \"<\/span> + s3);\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Dabei m\u00fcssen wir den Typ-Parameter (in diesem Fall String<\/code>) bei jeder instanceof<\/code>-Pr\u00fcfung mit angeben.<\/p>\n\n\n\n
Ab Java 20 kann der Compiler den Typ herleiten, so dass wir ihn bei den instanceof<\/code>-Pr\u00fcfungen weglassen k\u00f6nnen:<\/p>\n\n\n
if<\/span> (multi instanceof<\/span> Tuple<\/span>(var<\/span> s1, var<\/span> s2)<\/span>) <\/span>{\n  System.out.println(\"Tuple: \"<\/span> + s1 + \", \"<\/span> + s2);\n} else<\/span> if<\/span> (multi instanceof<\/span> Triple<\/span>(var<\/span> s1, var<\/span> s2, var<\/span> s3)<\/span>) <\/span>{\n  System.out.println(\"Triple: \"<\/span> + s1 + \", \"<\/span> + s2 + \", \"<\/span> + s3);\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Was mir dabei nicht gef\u00e4llt, ist dass hier die Syntax der sogenannten \"Raw Types\" verwendet wird. Raw Types f\u00fchren normalerweise dazu, dass der Compiler jegliche Typinformation ignoriert. Das ist hier aber nicht der Fall.<\/p>\n\n\n\n
Ich hielte es daher f\u00fcr konsistenter, hier den Diamond-Operator zu verwenden:<\/p>\n\n\n
if<\/span> (multi instanceof<\/span> Tuple<>(var<\/span> s1, var<\/span> s2)) {\n  System.out.println(\"Tuple: \"<\/span> + s1 + \", \"<\/span> + s2);\n} else<\/span> if<\/span> (multi instanceof<\/span> Triple<>(var<\/span> s1, var<\/span> s2, var<\/span> s3)) {\n  System.out.println(\"Triple: \"<\/span> + s1 + \", \"<\/span> + s2 + \", \"<\/span> + s3);\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Auch bei switch-Statements kann der Typ-Parameter ab Java 20 weggelassen werden.<\/p>\n\n\n\n
Record Patterns in for-Schleifen<\/h4>\n\n\n\n
Nehmen wir an, wir haben eine Liste von Positionen und wollen diese auf der Konsole ausgeben. Das konnten wir bisher so machen:<\/p>\n\n\n
List<Position> positions = ...\n\nfor<\/span> (Position p : positions) {\n  System.out.printf(\"(%d, %d)%n\"<\/span>, p.x(), p.y());\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Ab Java 20 k\u00f6nnen wir in der for-Schleife auch ein Record Pattern angeben und dann (genau wie bei instanceof<\/code> und switch<\/code>) direkt auf x<\/code> und y<\/code> zugreifen:<\/p>\n\n\n
for<\/span> (Position(int<\/span> x, int<\/span> y) : positions) {\n  System.out.printf(\"(%d, %d)%n\"<\/span>, x, y);\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Entfernung der Unterst\u00fctzung f\u00fcr benannte Record Patterns<\/h4>\n\n\n\n
Bisher gab es folgende drei M\u00f6glichkeiten, Pattern Matching mit einem Record durchzuf\u00fchren:<\/p>\n\n\n
Object object =  new<\/span> Position(4<\/span>, 3<\/span>);\n\n\/\/ 1. Pattern Matching for instanceof<\/span>\nif<\/span> (object instanceof<\/span> Position p) {\n  System.out.println(\"object is a position, p.x = \"<\/span> + p.x() + \", p.y = \"<\/span> + p.y());\n}\n\n\/\/ 2. Record Pattern<\/span>\nif<\/span> (object instanceof<\/span> Position<\/span>(int<\/span> x, int<\/span> y)<\/span>) <\/span>{\n  System.out.println(\"object is a position, x = \"<\/span> + x + \", y = \"<\/span> + y);\n}\n\n\/\/ 3. Named Record Pattern<\/span>\nif<\/span> (object instanceof<\/span> Position<\/span>(int<\/span> x, int<\/span> y)<\/span> p) <\/span>{\n  System.out.println(\"object is a position, p.x = \"<\/span> + p.x() + \", p.y = \"<\/span> + p.y() \n                                         + \", x = \"<\/span> + x + \", y = \"<\/span> + y);\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Bei der dritten Variante (\"Named Record Pattern\") gibt es zwei Wege, um auf die Felder des Records zuzugreifen \u2013 entweder \u00fcber die Variablen x<\/code> und y<\/code> \u2013 oder \u00fcber p.x()<\/code> und p.y()<\/code>. <\/p>\n\n\n\n
Diese Variante wurde f\u00fcr \u00fcberfl\u00fcssig befunden und daher in Java 20 wieder entfernt.<\/p>\n\n\n
Mit dem JDK Enhancement Proposal 432<\/a> wurden in Java 20 folgende \u00c4nderungen ver\u00f6ffentlicht:<\/p>\n\n\n\n