---
title: 'Abkürzende Schreibweisen für Lambda-Ausdrücke'
url: 'https://www.tutego.de/blog/javainsel/2012/12/abkrzende-schreibweisen-fr-lambda-ausdrcke'
markdown: 'https://www.tutego.de/blog/javainsel/2012/12/abkrzende-schreibweisen-fr-lambda-ausdrcke.md'
date: '2012-12-24'
description: 'Lambda-Ausdrücke haben wie Methoden mögliche Parameter und Rückgabe. Die Java-Grammatik für die Schreibweise von Lambda-Ausdrücken sieht ein paar syntaktische Abkürzungen vor, dir wir uns nun anschauen wollen. Typinferenz Der Java-Compiler kann viele Typen aus dem Kontext ablesen, was Typ-Inferenz …'
taxonomy:
  category:
    - Insel
    - 'Java 8'
---

# Abkürzende Schreibweisen für Lambda-Ausdrücke

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://www.tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://www.tutego.de/blog/javainsel/)

## Abkürzende Schreibweisen für Lambda-Ausdrücke

24.12.2012 · [Christian Ullenboom](https://www.tutego.de/blog/javainsel/author/admin/)

Lambda-Ausdrücke haben wie Methoden mögliche Parameter und Rückgabe. Die Java-Grammatik für die Schreibweise von Lambda-Ausdrücken sieht ein paar syntaktische Abkürzungen vor, dir wir uns nun anschauen wollen.

**Typinferenz**

Der Java-Compiler kann viele Typen aus dem Kontext ablesen, was Typ-Inferenz genannt wird. Wir kennen so etwas vom Diamanten, wenn wir schreiben `List`<`String`> list = new `ArrayList`<>();.

Statt

```java
Comparator<String> c = (String s1, String s2) -> { return s1.trim().compareTo( s2.trim() ); };
```

erlaubt der Compiler auch die Abkürzung:

```java
Comparator<String> c = (s1, s2) -> { return s1.trim().compareTo( s2.trim() ); };
```

Die Parameterliste enthält also deklarierte Parametertypen oder inferred-Typen. Eine Mischung ist nicht erlaubt, der Compiler blockt so etwas wie (`String` s1, s2) oder (s1, `String` s2) mit einem Fehler ab.

**Lambda-Rumpf ist entweder einzelner Ausdruck oder Block**

Besteht der Rumpf eines Lambda-Ausdrucks nur aus einem einzelnen Ausdruck, kann eine verkürzte Schreibweise die Block-Klammern und das Semikolon einsparen. Statt

‚(‚ *Parameter* ‚)‘ ‚->‘ ‚{‚ *Anweisungen*; ‚}‘

heißt es dann

‚(‚ Parameter ‚)‘ ‚->‘ Ausdruck

Lambda-Ausdrücke mit einer return–Anweisung im Rumpf kommen häufig vor (es entspricht den typischen Funktionen). Da ist es eine willkommene Verkürzung, wenn die abgekürzte Syntax für Lambda-Ausdrücke lediglich den Ausdruck fordert, der dann die Rückgabe bildet.

Drei Beispiele:

**Lange Schreibweise**

**Abkürzung**

```
(s1, s2) -> { return s1.trim().compareTo( s2.trim() ); }
```

(s1, s2) -> `s1.trim()`.`compareTo`( `s2.trim()` )

```
(a, b) -> { return a + b; }
```

(a, b) -> a + b

```java
() -> { System.out.println(); }

() -> System.out.println()
```

Ausdrücke können in Java auch zu void ausgewertet werden, sodass ohne Probleme ein Aufruf wie `System.out.println()` in der kompakten Schreibweise ohne Block gesetzt werden kann.

Ob Lambda-Ausdrücke eine Rückgabe geben, drücken zwei Begriffe aus:

- Der Rumpf kann in Anweisungen enden, die nichts zurück geben. Das nennt sich void-kompatibel.
- Der Rumpf beendet den Block mit einer return-Anweisung, die einen Wert zurückgibt. Das nennt sich Wert-kompatibel.

Eine Mischung aus void- und Wert-kompatibel ist nicht erlaubt und führt wie bei Methoden zu einem Compilerfehler.[\[1\]](file:C:/Users/Christian/Dropbox/Insel/todo/#_ftn1_4908)

**Einzelner Identifizierer statt Parameterliste und Klammern**

Besteht die Parameterliste nur aus einem einzelnen Identifizierer und ist der Typ durch Typ-Inferenz klar, können die runden Klammen wegfallen.

**Lange Schreibweise**

**Typen inferred**

**Vollständig abgekürzt**

(Sting s) -> `s.length()`

(s) -> `s.length()`

s -> `s.length()`

(int i) -> `Math.abs( i )`

(i) -> `Math.abs( i )`

i -> `Math.abs( i )`

Kommen alle Abkürzungen zusammen, lässt sich etwa die Hälfe einsparen. Aus (int i) -> { return `Math.abs( i )`; } wird dann i -> `Math.abs( i )`.

---

[\[1\]](file:C:/Users/Christian/Dropbox/Insel/todo/#_ftnref1_4908) Wohl aber gibt es wie bei { throw new `RuntimeException`(); } Ausnahmen, bei denen Lambda-Ausdrücke beides sind.

Kategorien: [Insel](https://www.tutego.de/blog/javainsel/category/insel/), [Java 8](https://www.tutego.de/blog/javainsel/category/java-8/)

[← Alle Beiträge](https://www.tutego.de/blog/javainsel/)

---

## Navigation

- Previous: [Funktionale Schnittstellen und Typ-Inferenz in Java 8](https://www.tutego.de/blog/javainsel/2012/12/funktionale-schnittstellen-in-java-8.md)
- Next: [Nicht AutoCloseable-Typen in try-mit-Ressourcen mithilfe von Lambda-Ausdrücken bzw. Methoden-Referenzen nutzen](https://www.tutego.de/blog/javainsel/2012/12/nicht-autocloseable-typen-in-try-mit-ressourcen-mithilfe-von-lambda-ausdrcken-bzw-methoden-referenzen-nutzen.md)