---
title: 'Einführung in Java 8 Lambda-Ausdrücke: Code sind Daten'
url: 'https://tutego.de/blog/javainsel/2012/12/einfhrung-in-java-8-lambda-ausdrcke-code-sind-daten'
markdown: 'https://tutego.de/blog/javainsel/2012/12/einfhrung-in-java-8-lambda-ausdrcke-code-sind-daten.md'
date: '2012-12-24'
description: 'Wer den Begriff „Daten“ hört, denkt zunächst einmal an Zahlen, Bytes, Zeichenketten oder auch komplexe Objekte mit ihrem Zustand. Wir wollen in diesem Kapitel diese Sicht ein wenig erweitern und auf Programmcode lenken. Java-Code, versinnbildlicht als Serie von Bytecodes, besteht auch aus Daten. Un…'
taxonomy:
  category:
    - Insel
    - 'Java 8'
---

# Einführung in Java 8 Lambda-Ausdrücke: Code sind Daten

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

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

## Einführung in Java 8 Lambda-Ausdrücke: Code sind Daten

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

Wer den Begriff „Daten“ hört, denkt zunächst einmal an Zahlen, Bytes, Zeichenketten oder auch komplexe Objekte mit ihrem Zustand. Wir wollen in diesem Kapitel diese Sicht ein wenig erweitern und auf Programmcode lenken. Java-Code, versinnbildlicht als Serie von Bytecodes, besteht auch aus Daten. Und wenn wir uns einmal auf diese Sichtweise einlassen, dass Code gleich Daten ist, dann lässt sich Code auch wie Daten übergeben und so von einem Punkt zum anderen übertragen, speichern und später referenzieren. Mit dieser Möglichkeit, Code zu übertragen, lässt sich das Verhalten von Algorithmen leicht anpassen. Beginnen wir mit ein paar Beispielen, bei denen Programmcode übergeben wird, auf den dann später zugegriffen wird:

- Ein `Thread` führt Programmcode im Hintergrund aus. Der Programmcode, den der Java-`Thread` ausführen soll, wird in ein Objekt vom Typ `Runnable` verpackt, genau genommen in eine `run()`-Methode gesetzt. Kommt der `Thread` zum Zuge, ruft er die `run()`-Methode auf.
- Ein Timer ist eine util-Klasse, die zu bestimmen Zeitpunkten Programmcode ausführen kann. Der Objektmethode `scheduleAtFixedRate(…)` wird dabei ein Objekt vom Typ TimerTask übergeben, das den Programmcode enthält.
- Zum Sortieren von Daten kann eine eigene Ordnung definiert werden, die dem Sortierer als `Comparator` übergeben werden kann. Der `Comparator` deklariert eine Vergleichsmethode, an die sich der Sortierer wendet, um zwei Objekte in die gewünschte Reihenfolge zu bringen.
- Aktiviert der Benutzer auf der Oberfläche eine Schaltfläche, so führt das zu einer Aktion. Der Programmcode steckt – beim UI-Framework Swing – in einem Objekt vom Typ ActionListener und wird an der Schaltfläche JButton mit `addActionListener(…)` fest gemacht. Kommt es zu einer Schaltflächenaktivierung, arbeitet das UI-System den Programmcode in der Methode `actionPerformed(…)` des gespeicherten ActionListener

Um Programmcode von einer Stelle zur anderen zu bringen, wird in Java immer der gleiche Mechanismus eingesetzt: Eine Klasse implementiert eine (in der Regel nichtstatische) Methode, in der der auszuführende Programmcode steht. Ein Objekt dieser Klasse wird an eine andere Stelle übergeben, und der Interessent greift dann über die Methode auf den Programmcode zu. Dass ein Objekt noch mehr als diese eine Implementierung enthalten kann, etwa Variablen, Konstanten, Konstruktoren, ist dafür nicht relevant. Diesen Mechanismus schauen wir uns jetzt in verschiedenen Varianten genauer an.

#### Innere Klassen als Code-Transporter

Bleiben wir bei dem Beispiel mit den Vergleichen. Angenommen, wir sollen Strings so sortieren, dass Leerraum vorne und hinten bei den Vergleichen ignoriert wird, also “ Newton “ gleich „Newton“ ist. Bei Vorgaben dieser Art muss einem Sortieralgorithmus ein Stückchen Code übergeben werden, damit er die korrekte Reihenfolge herstellen kann. Praktisch sieht das so aus:

```java
import java.util.*;
 public class CompareTrimmedStrings {
   public static void main( String[] args ) {
     class TrimmingComparator implements Comparator {
       @Override public int compare( String s1, String s2 ) {
         return s1.trim().compareTo( s2.trim() );
       }
     }
     String[] words = { "M", "\nSkyfall", " Q", "\t\tAdele\t" };
     Arrays.sort( words, new TrimmingComparator() );
     System.out.println( Arrays.toString( words ) );
   }
 }
```

Die Ausgabe ist:

```text
[        Adele    , M,  Q, 
 Skyfall]
```

Der `TrimmingComparator` enthält in der `compare(…)`-Methode den Programmcode für die Vergleichslogik. Ein Exemplar vom `TrimmingComparator` wird aufgebaut und `Arrays.sort(…)` übergeben. Das geht mit weniger Code!

#### Innere anonyme Klassen als Code-Transporter

Klassen enthalten Programmcode, und Exemplare der Klassen werden an Methoden wie `sort(…)` übergeben, damit der Programmcode dort hinkommt, wo er gebraucht wird. Doch elegant ist das nicht. Für die Beschreibung des Programmcodes ist extra eine eigene Klasse erforderlich. Das ist viel Schreibarbeit, und über eine innere anonyme Klasse lässt sich der Programmcode schon ein wenig verkürzen:

```java
String[] words = { "M", "\nSkyfall", " Q", "\t\tAdele\t" };
 Arrays.sort( words, new Comparator() {
   @Override public int compare( String s1, String s2 ) {
     return s1.trim().compareTo( s2.trim() );
   } } );
 System.out.println( Arrays.toString( words ) );
```

Allerdings ist das immer noch aufwändig: Wir müssen eine Methode überschreiben und dann ein Objekt aufbauen. Für Programmautoren ist das lästig, und die JVM hat es mit vielen überflüssigen Klassendeklarationen zu tun. Die Frage ist: Wenn der Compiler weiß, dass bei `sort(…)` ein `Comparator` nötig ist, und wenn ein `Comparator` sowieso nur eine Methode hat, muss dann `Comparator` und `compare(…)` überhaupt genannt werden?

#### Abkürzende Schreibweise durch Lambda-Ausdrücke

Mit Lambda-Ausdrücken lässt sich Programmcode leichter an eine Methode übergeben, denn es gibt eine kompakte Syntax für die Implementierung von Schnittstellen mit einer Operation. Für unser Beispiel sieht das so aus:

```java
String[] words = { "M", "\nSkyfall", " Q", "\t\tAdele\t" };
 Arrays.sort( words,
             (String s1, String s2) -> { return s1.trim().compareTo(s2.trim()); } );
 System.out.println( Arrays.toString( words ) );
```

Der in fett gesetzte Ausdruck nennt sich Lambda-Ausdruck. Er ist eine kompakte Art und Weise, Schnittstellen mit genau einer Methode zu implementieren; die Schnittstelle `Comparator` hat genau eine Operation `compare(…)`.

Optisch sind sich ein Lambda-Ausdruck und eine Methodendeklaration ähnlich; was wegfällt sind Modifizierer, der Rückgabetyp, der Methodenname und (mögliche) throws-Klauseln.

MethodendeklarationLambda-Ausdruckpublic int compare

```java
( String s1, String s2 ) { return s1.trim().compareTo( s2.trim() ); }
```

( `String` s1, `String` s2 ) ->

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

Tabelle 1.1: Vergleich der Methodendeklaration einer Schnittstelle mit dem Lambda-Ausdruck

Wenn wir uns den Lambda-Ausdruck als Implementierung dieser Schnittstelle anschauen, dann lässt sich dort nichts von `Comparator` oder `compare(…)` ablesen – ein Lambda-Ausdruck repräsentiert mehr oder weniger nur den Java-Code und lässt das, was der Compiler aus dem Kontext herleiten kann, weg.

Alle Lambda-Ausdrücke lassen sich in einer Syntax formulieren, die die folgende allgemeine Form hat:

```java
( LambdaParameter ) -> { Anweisungen }
```

Lambda-Parameter sind sozusagen die Eingabewerte für die Anweisungen. Die Parameterliste wird so deklariert, wie von Methoden oder Konstruktoren bekannt, allerdings gibt es keine Varargs. Es gibt syntaktische Abkürzungen, wie wir später sehen werden, doch vorerst bleiben wir bei dieser Schreibweise.

**Geschichte:** Der Java-Begriff „Lambda-Ausdruck“ geht auf das Lambda-Kalkül (in der englischen Literatur Lambda calculus genannt, auch geschrieben als λ-calculus) aus den 1930er Jahren zurück und ist eine formale Sprache zur Untersuchung von Funktionen.

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

## 4 Kommentare

**Peter Meier** · [05.12.2015 13:53](#comment-158076)

Der Blog scheint auch Trennstriche zu entfernen und hinterlässt somit unverständlichen Kauderwelsch. Wird wohl in Java mit Lambda-Ausdrücken geschrieben worden sein, da verliert man schon mal die Übersicht.

**Christian Ullenboom** · [18.07.2014 10:20](#comment-22241)

Nee, kein Schreibfehler, es geht doch um die Elimination von Weißraum -> der Blog entfernt schlichtweg den Backslash, also statt t und n \\\\t und \\\\n denken.

**Stephan** · [14.06.2014 21:33](#comment-21091)

Anmerkung zu: "Die Ausgabe ist: `\[ Adele , M, Q, Skyfall\]`" Das ist falsch, die Ausgabe für words = { "M", "nSkyfall", " Q", "ttAdelet" } ist "`\[M, Q, nSkyfall, ttAdelet\]`" ! Dass der gewünschte trim-Effekt nicht funktioniert (siehe das leerzeichen vor 'Q' im String\[\] words), liegt daran,dass `return s1.trim().compareTo( s2.trim() );` den return-Wert von compare zurückliefert nicht den von trim. trim arbeitet nicht destruktiv, sondern gibt einen neuen getrimten String zurück. Die Auswirkung von trim findet nur lokal im Aufruf von compare statt, wird aber nicht in das von Arrays.sort benutzen String\[\] words übertragen. Somit hat das ganze nicht den beschriebenen und gewünschten trim-Effekt. Das gilt auch für die nachfolgende Beispiele mit den Lambdas...! Ich denke das 'n' vor 'Skyfall' und die 't' vor und hinter Adele sind wohl ein Schreibfehler: `String\[\] words = { "M", "nSkyfall", " Q", "ttAdelet" };` Gruß Stephan

**Scala: Funktionale Programmierung | Sent from Hauptstadt!** · [21.03.2013 20:07](#comment-4502)

\\\[...\\\] Programmiersprachen entsprechende Konstrukte bzw. werden um diese erweitert. So werden in Java 8 die so genannten Lamba Ausdrücke eingeführt. Und nichts spricht dagegen, die Listenbibliothek von Java um Ausrücke für den Map-Reduce \\\[...\\\]

Die bisherigen Kommentare wurden aus WordPress übernommen. Neue Kommentare sind derzeit geschlossen.

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

---

## Navigation

- Previous: [Default-Methoden, Teil 2, Default-Methoden zur Entwicklung von Bausteinen nutzen](https://tutego.de/blog/javainsel/2012/12/default-methoden-teil-2-default-methoden-zur-entwicklung-von-bausteinen-nutzen.md)
- Next: [Deklaration und Syntax eines Java 8 Lambda-Ausdrucks](https://tutego.de/blog/javainsel/2012/12/deklaration-und-syntax-eines-java-8-lambda-ausdrucks.md)
