{"id":31297,"date":"2022-09-20T08:30:00","date_gmt":"2022-09-20T06:30:00","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=31297"},"modified":"2025-06-12T08:23:36","modified_gmt":"2025-06-12T06:23:36","slug":"java-19-features","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/java-19-features\/","title":{"rendered":"Java 19 Features (mit Beispielen)"},"content":{"rendered":"\n

Java 19 wurde am 20. September 2022 ver\u00f6ffentlicht. Du kannst es hier<\/a> herunterladen.<\/p>\n\n\n\n

Die spannendste Neuerung sind f\u00fcr mich die virtuellen Threads<\/a>, die seit mehreren Jahren im Rahmen von Project Loom<\/a> entwickelt werden und nun endlich als Preview im JDK enthalten sind.<\/p>\n\n\n\n

Virtuelle Threads sind die Voraussetzung f\u00fcr Structured Concurrency<\/a>, ein weiteres spannendes neues Incubator-Feature in Java 19.<\/p>\n\n\n\n

F\u00fcr alle, die auf Nicht-Java-Code (z. B. die C-Standard-Bibliothek) zugreifen wollen, gibt es ebenfalls gute Nachrichten: Die Foreign Function & Memory API<\/a> hat nach f\u00fcnf Incubator-Runden nun auch das Preview-Stadium erreicht.<\/p>\n\n\n\n

Wie immer verwende ich die englischen Bezeichnungen der JEPs.<\/p>\n\n\n\n\n\n

New Methods to Create Preallocated HashMaps<\/h2>\n\n\n\n

Wenn wir eine ArrayList<\/code> f\u00fcr eine vorab bekannte Anzahl an Elementen (z. B. 120) erzeugen wollen, dann k\u00f6nnen wir das seit jeher wie folgt tun:<\/p>\n\n\n

List<String> list = new<\/span> ArrayList<>(120<\/span>);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Dadruch wird das der ArrayList<\/code> zugrunde liegende Array direkt f\u00fcr 120 Elemente allokiert und muss nicht mehrfach vergr\u00f6\u00dfert (also neu angelegt und umkopiert) werden, um die 120 Elemente einzuf\u00fcgen.<\/p>\n\n\n\n
Ebenso k\u00f6nnen wir seit jeher eine HashMap<\/code> wie folgt erzeugen:<\/p>\n\n\n
Map<String, Integer> map = new<\/span> HashMap<>(120<\/span>);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Intuitiv w\u00fcrde man denken, diese HashMap<\/code> biete Platz f\u00fcr 120 Mappings.<\/p>\n\n\n\n
Das ist allerdings nicht der Fall!<\/p>\n\n\n\n
Denn die HashMap<\/code> wird mit einem Default-Load-Faktor von 0,75 initialisiert. Das bedeutet: Sobald die HashMap<\/code> zu 75 % gef\u00fcllt ist, wird sie mit doppelter Gr\u00f6\u00dfe neu aufgebaut (\"rehashed\"). Dadurch soll sichergestellt werden, dass die Elemente m\u00f6glichst gleichm\u00e4\u00dfig auf die Buckets der HashMap<\/code> verteilt sind und m\u00f6glichst kein Bucket mehr als ein Element enth\u00e4lt.<\/p>\n\n\n\n
Die mit einer Kapazit\u00e4t von 120 initialisierte HashMap<\/code> kann also nur 120 \u00d7 0,75 = 90 Mappings aufnehmen.<\/p>\n\n\n\n
Um eine HashMap<\/code> f\u00fcr 120 Mappings zu erzeugen, musste man bisher die Kapazit\u00e4t selbst berechnen, indem man die Anzahl der Mappings durch den Load-Faktor teilt: 120 \u00f7 0,75 = 160.<\/p>\n\n\n\n
Eine HashMap<\/code> f\u00fcr 120 Mappings musste also wie folgt angelegt werden:<\/p>\n\n\n
\/\/ for 120 mappings: 120 \/ 0.75 = 160<\/span>\nMap<String, Integer> map = new<\/span> HashMap<>(160<\/span>); \n<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Java 19 macht uns das einfacher \u2013 wir k\u00f6nnen stattdessen jetzt folgendes schreiben:<\/p>\n\n\n
Map<String, Integer> map = HashMap.newHashMap(120<\/span>);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Wenn wir uns den Quellcode der neuen Methoden anschauen, sehen wir, dass im Endeffekt das gleiche passiert, was wir vorher manuell gemacht haben:<\/p>\n\n\n
public<\/span> static<\/span> <K, V> HashMap<K, V> newHashMap<\/span>(int<\/span> numMappings)<\/span> <\/span>{\n    return<\/span> new<\/span> HashMap<>(calculateHashMapCapacity(numMappings));\n}\n\nstatic<\/span> final<\/span> float<\/span> DEFAULT_LOAD_FACTOR = 0.75f<\/span>;\n\nstatic<\/span> int<\/span> calculateHashMapCapacity<\/span>(int<\/span> numMappings)<\/span> <\/span>{\n    return<\/span> (int<\/span>) Math.ceil(numMappings \/ (double<\/span>) DEFAULT_LOAD_FACTOR);\n}\n<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Die newHashMap()<\/code>-Methode wurde ebenfalls in LinkedHashMap<\/code> und WeakHashMap<\/code> eingebaut.<\/p>\n\n\n\n
Zu dieser Erweiterung gibt es kein JDK Enhancement Proposal.<\/p>\n\n\n\n
Preview- und Incubator-Features<\/h2>\n\n\n\n
Java 19 liefert uns insgesamt sechs Preview- und Incubator-Features, also Features, die noch nicht fertiggestellt sind, die von der Entwickler-Community aber bereits getestet werden k\u00f6nnen. Das Feedback der Community geht in der Regel in die Weiterentwicklung und Fertigstellung dieser Features ein.<\/p>\n\n\n\n
Pattern Matching for switch (Third Preview) \u2013 JEP 427<\/h3>\n\n\n\n
Fangen wir mit einem Feature an, das bereits zwei Preview-Runden hinter sich hat. Das in Java 17<\/a> erstmals vorgestellte \"Pattern Matching for switch\" erlaubte uns Code wie den folgenden zu schreiben:<\/p>\n\n\n
switch<\/span> (obj) {\n  case<\/span> String s && s.length() > 5<\/span> -> System.out.println(s.toUpperCase());\n  case<\/span> String s                   -> System.out.println(s.toLowerCase());\n\n  case<\/span> Integer i                  -> System.out.println(i * i);\n\n  default<\/span> -> {}\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Wir k\u00f6nnen damit innerhalb eines switch<\/code>-Statements pr\u00fcfen, ob ein Objekt von einer bestimmten Klasse ist und ob es ggf. weitere Eigenschaften (wie im Beispiel: l\u00e4nger als 5 Zeichen) aufweist.<\/p>\n\n\n\n
Das Beispiel von oben wird in Java 19 wie folgt notiert:<\/p>\n\n\n
switch<\/span> (obj) {\n  case<\/span> String s when s.length() > 5<\/span> -> System.out.println(s.toUpperCase());\n  case<\/span> String s                     -> System.out.println(s.toLowerCase());\n\n  case<\/span> Integer i                    -> System.out.println(i * i);\n\n  default<\/span> -> {}\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
when<\/code> ist ein sogenanntes \"contextual keyword\" und hat damit nur innerhalb eines case<\/code>-Labels eine Bedeutung. Solltest du in deinem Code Variablen oder Methoden mit dem Namen \"when\" haben, musst du daran nichts \u00e4ndern.<\/p>\n\n\n\n
Record Patterns (Preview) \u2013 JEP 405<\/h3>\n\n\n\n
Wir bleiben beim Thema \"Pattern Matching\" und kommen zu den \"Record Patterns\". Wenn das Thema \"Records\" neu f\u00fcr dich ist, empfehle ich dir zun\u00e4chst den Artikel \"Records in Java<\/a>\" zu lesen.<\/p>\n\n\n\n
Was ein Record Pattern ist, erkl\u00e4re ich am besten an einem Beispiel. Nehmen wir an, wir haben folgenden Record definiert:<\/p>\n\n\n
public<\/span> record Position<\/span>(int<\/span> x, int<\/span> y)<\/span> <\/span>{}\n<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Au\u00dferdem haben wir eine print()<\/code>-Methode, die beliebige Objekte, unter anderem auch Positionen, ausgeben kann:<\/p>\n\n\n
private<\/span> void<\/span> print<\/span>(Object object)<\/span> <\/span>{\n  if<\/span> (object instanceof<\/span> Position position) {\n    System.out.println(\"object is a position, x = \"<\/span> + position.x() \n                                         + \", y = \"<\/span> + position.y());\n  }\n  \/\/ else ...<\/span>\n}\n<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Record Pattern mit instanceof<\/h4>\n\n\n\n
Ab Java 19 erm\u00f6glicht uns JDK Enhancement Proposal 405<\/a> ein sogenanntes \"Record Pattern\" einzusetzen. Damit k\u00f6nnen wir den Code auch wie folgt schreiben:<\/p>\n\n\n
private<\/span> void<\/span> print<\/span>(Object object)<\/span> <\/span>{\n  if<\/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  \/\/ else ...<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Anstatt auf \"Position position<\/code>\" zu matchen und im nachfolgenden Code auf position<\/code> zuzugreifen, matchen wir nun auf \"Position(int x, int y)<\/code>\" und k\u00f6nnen im folgenden Code direkt auf x<\/code> und y<\/code> zugreifen.<\/p>\n\n\n\n
Record Pattern mit switch<\/h4>\n\n\n\n
Das urspr\u00fcngliche Beispiel k\u00f6nnen wir seit Java 17<\/a> auch als switch<\/code>-Statement schreiben:<\/p>\n\n\n
private<\/span> void<\/span> print<\/span>(Object object)<\/span> <\/span>{\n  switch<\/span> (object) {\n    case<\/span> Position position\n        -> System.out.println(\"object is a position, x = \"<\/span> + position.x() \n                                                + \", y = \"<\/span> + position.y());\n    \/\/ other cases ...<\/span>\n  }\n}\n<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Auch im switch-Statement k\u00f6nnen wir seit Java 19 ein Record Pattern benutzen:<\/p>\n\n\n
private<\/span> void<\/span> print<\/span>(Object object)<\/span> <\/span>{\n  switch<\/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  }\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Verschachtelte Record Patterns<\/h4>\n\n\n\n
Es ist auch m\u00f6glich verschachtelte Records zu matchen \u2013 auch das m\u00f6chte ich an einem Beispiel demonstrieren.<\/p>\n\n\n\n
Wir definieren zun\u00e4chst einen zweiten Record, Path<\/code>, mit einer Start- und einer Zielposition:<\/p>\n\n\n
public<\/span> record Path<\/span>(Position from, Position to)<\/span> <\/span>{}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Unsere print()<\/code>-Methode kann nun mit Hilfe eines Record Patterns ganz einfach alle X- und Y-Koordinaten des Pfades ausgeben:<\/p>\n\n\n
private<\/span> void<\/span> print<\/span>(Object object)<\/span> <\/span>{\n  if<\/span> (object instanceof<\/span> Path<\/span>(Position(int<\/span> x1, int<\/span> y1)<\/span>, Position<\/span>(int<\/span> x2, int<\/span> y2)<\/span>)) <\/span>{\n    System.out.println(\"object is a path, x1 = \"<\/span> + x1 + \", y1 = \"<\/span> + y1 \n                                     + \", x2 = \"<\/span> + x2 + \", y2 = \"<\/span> + y2);\n  }\n  \/\/ else ...<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Auch das k\u00f6nnen wir alternativ als switch<\/code>-Statement schreiben:<\/p>\n\n\n
private<\/span> void<\/span> print<\/span>(Object object)<\/span> <\/span>{\n  switch<\/span> (object) {\n    case<\/span> Path<\/span>(Position(int<\/span> x1, int<\/span> y1)<\/span>, Position<\/span>(int<\/span> x2, int<\/span> y2)<\/span>)\n        -> System.out.println<\/span>(\"object is a path, x1 = \"<\/span> + x1 + \", y1 = \"<\/span> + y1 \n                                            + \", x2 = \"<\/span> + x2 + \", y2 = \"<\/span> + y2)<\/span><\/span>;\n    \/\/ other cases ...<\/span>\n  }\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Record Patterns bieten uns also eine elegante M\u00f6glichkeit nach einer Typpr\u00fcfung auf die Elemente eines Records zuzugreifen.<\/p>\n\n\n
Falls du \u00fcber die verwendete Schreibweise stolperst \u2013 sie wurde in Java 16<\/a> als \"Pattern Matching for instanceof\" eingef\u00fchrt.<\/p>\n\n\n\n
In Java 19 wurde mit JDK Enhancement Proposal 427<\/a> die Syntax des sogenannten \"Guarded Patterns\" (im Beispiel oben \"String s && s.length() > 5<\/code>\") ver\u00e4ndert. Statt &&<\/code> muss nun das neue Keyword when<\/code> verwendet werden.<\/p>\n\n\n\n