{"id":23301,"date":"2021-10-26T14:45:13","date_gmt":"2021-10-26T12:45:13","guid":{"rendered":"https:\/\/www.happycoders.eu\/?p=23301"},"modified":"2024-11-27T14:59:55","modified_gmt":"2024-11-27T13:59:55","slug":"java-11-features","status":"publish","type":"post","link":"https:\/\/www.happycoders.eu\/de\/java\/java-11-features\/","title":{"rendered":"Java 11 Features (mit Beispielen)"},"content":{"rendered":"\n

Mit Java 11 wurde am 25. September 2018 das erste Long-Term-Support (LTS)-Release des JDK seit der Umstellung auf den sechsmonatige Release-Zyklus ver\u00f6ffentlicht. \"Long-Term-Support\" bedeutet, dass Oracle diese Version f\u00fcr mehrere Jahre mit Sicherheitspatches ausstatten wird.<\/p>\n\n\n\n

Die letzte LTS-Version war Java 8. Java 9 und 10 waren keine<\/em> LTS-Releases, was bedeutet, dass der Support dieser Versionen mit der jeweils folgenden Version eingestellt wurde.<\/p>\n\n\n\n

Ich habe die \u00c4nderungen in Java 11 nach Relevanz f\u00fcr die t\u00e4gliche Entwicklerarbeit sortiert. Zuerst kommen \u00c4nderungen an der Sprache selbst. Es folgen Erweiterungen an der JDK-Klassenbibliothek, Tools und experimentelle Features. Und zuletzt Deprecations, L\u00f6schungen und sonstige kleine \u00c4nderungen.<\/p>\n\n\n\n

Wichtig ist noch zu wissen, dass das Oracle-JDK ab Version 11 nur noch f\u00fcr Entwickler frei nutzbar ist. Firmen ben\u00f6tigen einen kostenpflichtigen Supportvertrag mit Oracle. Open<\/em>JDK 11 hingegen ist f\u00fcr alle frei einsetzbar.<\/p>\n\n\n\n

Local-Variable Syntax for Lambda Parameters<\/h2>\n\n\n\n

Mit dem JDK Enhancement Proposal 323<\/a> wird die Verwendung von \"var\" in Parametern von implizit typisierten Lambda-Ausdr\u00fccken erlaubt.<\/p>\n\n\n\n

Was ist ein implizit typisierter<\/em> Lambda-Ausdruck?<\/p>\n\n\n\n

Fangen wir mit einem explizit<\/em> typisierten Lambda-Ausdruck an. Explizit<\/em> bedeutet in folgendem Beispiel, dass die Datentypen der Lambda-Parameter l<\/code> und s<\/code> \u2013 also List<String><\/code> und String<\/code> \u2013 mit angegeben sind:<\/p>\n\n\n

(List<String> l, String s) -> l.add(s);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Der Compiler kann die Typen allerdings auch aus dem Kontext herleiten, so dass auch folgende \u2013 implizit<\/em> typisierte \u2013 Schreibweise erlaubt ist:<\/p>\n\n\n
(l, s) -> l.add(s);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
(var<\/span> l, var<\/span> s) -> l.add(s);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Doch warum sollte man \"var\" schreiben, wenn man die Typen, wie im Beispiel davor, komplett weglassen kann?<\/p>\n\n\n\n
Der Grund daf\u00fcr sind Annotationen. Soll eine Variable annotiert werden, muss die Annotation am Typ stehen \u2013 das kann ein expliziter Typ sein oder auch \"var\". Eine Annotation direkt am Variablennamen ist nicht erlaubt.<\/p>\n\n\n\n
M\u00f6chte man die Variablen im obigen Beispiel-Lambda annotieren, war bisher nur folgende Schreibweise m\u00f6glich:<\/p>\n\n\n
(@Nonnull<\/span> List<String> l, @Nullable<\/span> String s) -> l.add(s);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Java 11 erlaubt mit \"var\" nun auch folgende, k\u00fcrzere Variante:<\/p>\n\n\n
(@Nonnull<\/span> var<\/span> l, @Nullable<\/span> var<\/span> s) -> l.add(s);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Die verschiedenen Schreibweisen d\u00fcrfen nicht gemischt werden. D. h. du musst entweder f\u00fcr alle Variablen den Typ angeben, alle Typen weglassen oder bei allen Variablen \"var\" verwenden.<\/p>\n\n\n\n
Welche Form du letztendlich w\u00e4hlst, h\u00e4ngt von der Lesbarkeit im konkreten Fall und den Stil-Vorgaben deines Teams ab.<\/p>\n\n\n\n
HTTP Client (Standard)<\/h2>\n\n\n\n
Um vor Java 11 mit JDK-Hausmitteln Daten z. B. per HTTP-POST zu versenden, war eine ganze Menge Code erforderlich.<\/p>\n\n\n\n
(Das folgende Beispiel verwendet dabei das in Java 8 hinzugekommene BufferedReader.lines()<\/code>, um die Antwort als Stream zu lesen und per Collector zu einem String zusammenzufassen. Vor Java 8 waren hierf\u00fcr noch einige Zeilen mehr n\u00f6tig.)<\/p>\n\n\n
public<\/span> String post<\/span>(String url, String data)<\/span> throws<\/span> IOException <\/span>{\n  URL urlObj = new<\/span> URL(url);\n  HttpURLConnection con = (HttpURLConnection) urlObj.openConnection();\n  con.setRequestMethod(\"POST\"<\/span>);\n  con.setRequestProperty(\"Content-Type\"<\/span>, \"application\/json\"<\/span>);\n\n  \/\/ Send data<\/span>\n  con.setDoOutput(true<\/span>);\n  try<\/span> (OutputStream os = con.getOutputStream()) {\n    byte<\/span>[] input = data.getBytes(StandardCharsets.UTF_8);\n    os.write(input, 0<\/span>, input.length);\n  }\n\n  \/\/ Handle HTTP errors<\/span>\n  if<\/span> (con.getResponseCode() != 200<\/span>) {\n    con.disconnect();\n    throw<\/span> new<\/span> IOException(\"HTTP response status: \"<\/span> + con.getResponseCode());\n  }\n\n  \/\/ Read response<\/span>\n  String body;\n  try<\/span> (InputStreamReader isr = new<\/span> InputStreamReader(con.getInputStream());\n      BufferedReader br = new<\/span> BufferedReader(isr)) {\n    body = br.lines().collect(Collectors.joining(\"\\n\"<\/span>));\n  }\n  con.disconnect();\n\n  return<\/span> body;\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Den Code oben kann man mit HttpClient<\/code> deutlich k\u00fcrzer und aussagekr\u00e4ftiger schreiben:<\/p>\n\n\n
public<\/span> String post<\/span>(String url, String data)<\/span> throws<\/span> IOException, InterruptedException <\/span>{\n  HttpClient client = HttpClient.newHttpClient();\n\n  HttpRequest request =\n      HttpRequest.newBuilder()\n          .uri(URI.create(url))\n          .header(\"Content-Type\"<\/span>, \"application\/json\"<\/span>)\n          .POST(BodyPublishers.ofString(data))\n          .build();\n\n  HttpResponse<String> response = client.send(request, BodyHandlers.ofString());\n\n  if<\/span> (response.statusCode() != 200<\/span>) {\n    throw<\/span> new<\/span> IOException(\"HTTP response status: \"<\/span> + response.statusCode());\n  }\n\n  return<\/span> response.body();\n}<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
Die neue HttpClient<\/code>-Klasse ist vielseitig einsetzbar:<\/p>\n\n\n\n
Das JDK 11 enth\u00e4lt die neue Klasse HttpClient<\/a>, die die Arbeit mit HTTP wesentlich vereinfacht.<\/p>\n\n\n\n
Seit Java 11 kann anstelle der expliziten Typen auch das in Java 10 eingef\u00fchrte \"var\"<\/a> verwendet werden:<\/p>\n\n\n