{"id":2731,"date":"2014-03-21T11:46:33","date_gmt":"2014-03-21T09:46:33","guid":{"rendered":"http:\/\/www.tutego.de\/blog\/javainsel\/?p=2731"},"modified":"2017-06-19T14:11:24","modified_gmt":"2017-06-19T12:11:24","slug":"java-8-syntax-lambda-ausdruecke","status":"publish","type":"post","link":"https:\/\/www.tutego.de\/blog\/javainsel\/2014\/03\/java-8-syntax-lambda-ausdruecke\/","title":{"rendered":"Syntax f\u00fcr Lambda-Ausdr\u00fccke"},"content":{"rendered":"

Lambda-Ausdr\u00fccke haben wie Methoden m\u00f6gliche Parameter- und R\u00fcckgabe-Werte. Die Java-Grammatik f\u00fcr die Schreibweise von Lambda-Ausdr\u00fccken sieht ein paar n\u00fctzliche syntaktische Abk\u00fcrzungen vor.<\/p>\n

Ausf\u00fchrliche Schreibweise<\/h4>\n

Lambda-Ausdr\u00fccke lassen sich auf unterschiedliche Arten und Weisen schreiben, da es f\u00fcr diverse Konstruktionen Abk\u00fcrzungen gibt. Eine Form, die jedoch immer gilt ist:<\/p>\n

‚(‚ LambdaParameter<\/i> ‚)‘ ‚->‘ ‚{‚ Anweisungen<\/i> ‚}‘<\/p>\n

Der Lambda-Parameter besteht (voll ausgeschrieben) wie ein Methodenparameter aus a) dem Typ, b) dem Namen und c) optionalen Modifizieren.<\/p>\n

Der Parametername \u00f6ffnet einen neuen G\u00fcltigkeitsbereich f\u00fcr eine Variable, wobei der Parametername keine<\/i> anderen Namen von lokalen Variablen \u00fcberlagern darf. Hier verh\u00e4lt sich die Lambda-Parametervariable wie eine neue Variable aus einem inneren Block und nicht wie eine Variable<\/span> aus einer inneren Klasse, wo die Sichtbarkeit anders ist.<\/p>\n

Beispiel<\/p>\n

Folgendes gibt einen Compilerfehler im Lambda-Ausdruck, weil var schon deklariert ist, die Parametervariable vom Lambda-Ausdruck muss also \u201efrisch\u201c sein:<\/p>\n

String var<\/b> = \"\";\r\nvar.chars().forEach( var<\/b> -> { System.out.println( var ); } );\u00a0 \/\/ \u00a0Compilerfehler<\/pre>\n
Abk\u00fcrzung 1: Typinferenz<\/h4>\n
Der Java-Compiler kann viele Typen aus dem Kontext ablesen, was Typ-Inferenz genannt wird. Wir kennen so etwas vom Diamant-Operator, wenn wir etwa schreiben List<String> list = new ArrayList<>().<\/p>\n
Sind f\u00fcr den Compiler genug Typ-Informationen verf\u00fcgbar, dann erlaubt der Compiler bei Lambda-Ausdr\u00fccken eine Abk\u00fcrzung. Bei<\/p>\n
Comparator<String> c =\r\n\u00a0 (String s1, String s2<\/b>) -> { return s1.trim().compareTo( s2.trim() ); };<\/pre>\n
ist Typ-Inferenz einfach (Comparator<String> sagt alles aus), daher funktioniert die folgende\u00a0 Abk\u00fcrzung:<\/p>\n
Comparator<String> c = (s1, s2<\/b>) -> { return s1.trim().compareTo( s2.trim() ); };<\/pre>\n
Die Parameterliste enth\u00e4lt also entweder explizit deklarierte Parametertypen oder implizite inferred-Typen. Eine Mischung ist nicht erlaubt, der Compiler blockt so etwas wie (String s1, s2) oder (s1, String s2) mit einem Fehler ab.<\/p>\n
Wenn der Compiler die Typen ablesen kann, sind die Parametertypen optional. Aber Typ-Inferenz ist nicht immer m\u00f6glich, weshalb die Abk\u00fcrzung nicht immer m\u00f6glich ist. Au\u00dferdem hilft die explizite Schreibweise auch der Lesbarkeit: kurze Ausdr\u00fccke sind nicht unbedingt die verst\u00e4ndlichsten.<\/p>\n
Hinweis<\/p>\n
Der Compiler liest aus den Typen ab, ob alle Eigenschaften vorhanden sind. Die Typen sind dabei entweder explizit oder implizit gegeben.<\/p>\n
Comparator<String<\/b>> sc = (a, b) -> { return Integer.compare( a.length(), b.length() ); };\r\nComparator<BitSet<\/b>> bc = (a, b) -> { return Integer.compare( a.length(), b.length() ); };<\/pre>\n
Die Klassen String und BitSet besitzen beide die Methode length(), daher ist der Lambda-Ausdruck korrekt. Der gleiche Lambda-Code l\u00e4sst sich f\u00fcr zwei v\u00f6llig verschiedene Klassen einsetzen, die \u00fcberhaupt keine Gemeinsamkeiten haben, nur das sie zuf\u00e4llig beide eine Methode namens length() besitzen.<\/p>\n
Abk\u00fcrzung 2: Lambda-Rumpf ist entweder einzelner Ausdruck oder Block<\/h4>\n
Besteht der Rumpf eines Lambda-Ausdrucks nur aus einem einzelnen Ausdruck, kann eine verk\u00fcrzte Schreibweise die Block-Klammern und das Semikolon einsparen. Statt<\/p>\n
( LambdaParameter<\/i> ) -> { return Ausdruck;<\/i> }<\/p>\n
hei\u00dft es dann<\/p>\n
( LambdaParameter<\/i> ) -> Ausdruck<\/i><\/p>\n
Lambda-Ausdr\u00fccke mit einer return\u2013Anweisung im Rumpf kommen h\u00e4ufig vor, da dies den typischen Funktionen entspricht. Somit ist es eine willkommene Verk\u00fcrzung, wenn die abgek\u00fcrzte Syntax f\u00fcr Lambda-Ausdr\u00fccke lediglich den Ausdruck fordert, der dann die R\u00fcckgabe bildet.<\/p>\n
Hier sind drei Beispiele:<\/p>\n\n\n\n\n\n\n
Lange Schreibweise<\/td>\nAbk\u00fcrzung<\/td>\n<\/tr>\n
(s1, s2) -><\/p>\n
{ return s1.trim().compareTo( s2.trim() ); }<\/td>\n
(s1, s2) -><\/p>\n
s1.trim().compareTo( s2.trim() )<\/td>\n<\/tr>\n
(a, b) -> { return a + b; }<\/td>\n(a, b) -> a + b<\/td>\n<\/tr>\n
() -> { System.out.println(); }<\/td>\n() -> System.out.println()<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Ausf\u00fchrliche und abgek\u00fcrzte Schreibweise<\/p>\n
Ausdr\u00fccke k\u00f6nnen in Java auch zu void ausgewertet werden, sodass ohne Probleme ein Aufruf wie\u00a0 System.out.println() in der kompakten Schreibweise ohne Block gesetzt werden kann. Das hei\u00dft, wenn Lambda-Ausdr\u00fccke mit der kurzen Ausdrucks-Syntax eingesetzt werden, k\u00f6nnen diese Ausdr\u00fccke etwas zur\u00fcckgeben, m\u00fcssen aber nicht.<\/p>\n
Hinweis<\/p>\n
Die Schreibweise mit den geschweiften Klammern und den R\u00fcckgabe-Ausdr\u00fccken kann nicht gemischt werden. Entweder gibt es ein Block geschweifter Klammern und return oder keine Klammern und kein return-Schl\u00fcsselwort. Fehler ergeben also diese falschen Mischungen:<\/p>\n
Comparator<String> c;\r\nc = (s1, s2) -> {<\/b> s1.trim().compareTo( s2.trim() ) }<\/b>;\u00a0\u00a0\u00a0 \/\/ Compilerfehler (1)\r\nc = (s1, s2) -> return<\/b> s1.trim().compareTo( s2.trim() ); \/\/ Compilerfehler (2)<\/pre>\n
W\u00fcrden wir in (1) ein explizites return nutzen w\u00e4re alles in Ordnung, w\u00fcrde bei (2) das return wegfallen w\u00e4re die Zeile auch compilierbar.<\/p>\n
Ob Lambda-Ausdr\u00fccke eine R\u00fcckgabe haben, dr\u00fccken zwei Begriffe aus:<\/p>\n