---
title: 'Methoden-Referenzen in Java 8'
url: 'https://www.tutego.de/blog/javainsel/2012/12/methoden-referenzen-in-java-8'
markdown: 'https://www.tutego.de/blog/javainsel/2012/12/methoden-referenzen-in-java-8.md'
date: '2012-12-29'
description: 'Je größer Software-Systeme werden, desto wichtiger werden Aspekte wie Klarheit, Wiederverwendbarkeit und Dokumentation. Wir haben in für unseren String-Comparator eine Implementierung geschrieben, anfangs über eine innere Klasse, später über einen Lambda-Ausdruck, in jedem Fall haben wir Code gesch…'
taxonomy:
  category:
    - Insel
    - 'Java 8'
---

# Methoden-Referenzen in Java 8

![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/)

## Methoden-Referenzen in Java 8

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

Je größer Software-Systeme werden, desto wichtiger werden Aspekte wie Klarheit, Wiederverwendbarkeit und Dokumentation. Wir haben in für unseren `String`-`Comparator` eine Implementierung geschrieben, anfangs über eine innere Klasse, später über einen Lambda-Ausdruck, in jedem Fall haben wir Code geschrieben. Doch was wäre, wenn eine Utility-Klasse schon eine Implementierung hätte? Kann könnte der Lambda-Ausdruck natürlich an die vorhandene Implementierung delegieren.

```java
class StringUtils {
  public static int compareTrimmed( String s1, String s2 ) {
    return s1.trim().compareTo( s2.trim() );
  }     
}

public class CompareIgnoreCase {
  public static void main( String[] args ) throws Exception {
    String[] words = { "A", "B", "a" };
      Arrays.sort( words, (String s1, String s2) -> StringUtils.compareTrimmed(s1, s2) );
      System.out.println( Arrays.toString( words ) );
  }
}
```

Auffällig bei dem Beispiel ist, dass die referenzierte Methode `compareTrimmed(String,String)` von den Parametertypen und vom Rückgabetyp genau auf die `compare(…)`-Methode eines `Comparator` passt. Für genau solche Fälle gibt es eine weitere syntaktische Verkürzung, dass Entwickler im Code kein Lambda-Ausdruck mehr schreiben müssen.

**Definition**: Methoden-Referenzen identifizieren Methoden ohne sie aufzurufen. Syntaktisch trennen zwei Doppelpunkte den Klassenamen bzw. die Referenz auf der linken Seite von einem Methodennamen auf der rechten.

Die Zeile

```java
Arrays.sort( words, (String s1, String s2) -> StringUtils.compareTrimmed(s1, s2) );
```

lässt sich mit Methoden-Referenzen abkürzen zu:

```java
Arrays.sort( words, StringUtils::compareTrimmed );
```

Die Sortiermethode erwartet vom `Comparator` eine Methode, die zwei Strings annimmt und eine Ganzzahl zurückgibt. Der Name der Klasse und der Name der Methode ist unerheblich, weshalb Methoden-Referenzen eingesetzt werden können.

Eine Methoden-Referenz ist wie ein Lambda-Ausdruck ein Exemplar einer funktionalen Schnittstelle, jedoch für eine existierende Methode einer bekannten Klasse. Wie üblich bestimmt der Kontext von welchem Typ genau der Ausdruck ist.

**Beispiel**: Gleicher Code für eine Methoden-Referenz kann zu komplett unterschiedlichen Typen führen – der Kontext macht den Unterschied:

```java
Comparator<String> c = StringUtils::compareTrimmed;

BiFunction<String, String, Integer> c = StringUtils::compareTrimmed;
```

Im Beispiel war die Methode `compareTrimmed(…)` statisch, und links vom Doppeltpunkt steht der Name einer Klasse stehen. Doch kann links auch eine Referenz stehen, was dann eine Objektmethode referenziert.

**Beispiel**: Die statische Variable `String`.CASE\_INSENSITIVE\_ORDER enthält eine Referenz auf ein `Comparator`-Objekt:

```java
Comparator<String> c = String.CASE_INSENSITIVE_ORDER;
```

Wir können auch mit Methoden-Referenzen arbeiten:

```java
Comparator<String> c = String.CASE_INSENSITIVE_ORDER::compare;
```

Statt dass der Name einer Referenzvariablen gewählt wird, kann auch this das Objekt beschreiben.

**Was soll das alles?**

Für Einsteiger in die Sprache Java wird dieses Sprache-Feature wie der größte Zauber auf Erden vorkommen und auch Java-Profis bekommen hier zittrige Finger, entweder vor Angst oder Freunde… In der Vergangenheit musste in Java sehr viel explizit geschrieben werden, aber mit diesen neuen Methoden-Referenzen sieht und macht der Compiler vieles von selbst.

Nützlich wird diese Eigenschaft mit den funktionalen Bibliotheken aus Java 8, die ein eigenes Kapitel einnehmen. Nur kurz:

```java
String[] words = { "3", "2", " 1", "" };
Arrays.stream( words )
      .map( String::trim )
      .filter( (s) -> s != null && ! s.isEmpty() )
      .map( Integer::parseInt )
      .sorted()
      .forEach( System.out::println );   // 1 2 3
```

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

## 2 Kommentare

**Davis** · [16.03.2016 13:31](#comment-444685)

Ich hab auch noch einen Schreibfehler gefunden! Du schreibst oben "Kann könnte der Lambda-Ausdruck" Ich bin mir fast sicher, dass das nicht so sein sollte ^^

**Stephan** · [25.06.2014 13:04](#comment-21375)

Schreibfehler in: "Im Beispiel war die Methode compareTrimmed(…) statisch, und links vom Doppeltpunkt steht der Name einer Klasse stehen." Gruß Stephan

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

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

---

## Navigation

- Previous: [Die Umgebung der Lambda-Ausdrücke und Variablenzugriffe](https://www.tutego.de/blog/javainsel/2012/12/die-umgebung-der-lambda-ausdrcke-und-variablenzugriffe.md)
- Next: [filter map map filter map sorted forEach, wird das die Zukunft sein?](https://www.tutego.de/blog/javainsel/2012/12/filter-map-map-filter-map-sorted-foreach-wird-das-die-zukunft-sein.md)