Java 8 Method References: Methoden als Werte weiterreichen (:: Operator)

Was sind Method References?

Ein Method Reference (::) ist eine kompakte Schreibweise für Lambdas, die nur eine existierende Methode aufrufen. Statt x -> System.out.println(x) schreiben Sie System.out::println.

Vier Arten von Method References

Beispiel: Liste ausgeben

import java.util.*;

public class MethodRefDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Anna", "Bernd", "Clara");

        // Static method reference
        names.forEach(System.out::println);

        // Instance method of arbitrary object (String::toUpperCase)
        List<String> upper = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        System.out.println(upper); // [ANNA, BERND, CLARA]

        // Constructor reference
        List<ArrayList<String>> lists = names.stream()
            .map(n -> new ArrayList<String>()) // Lambda nötig, da Parameter
            .collect(Collectors.toList());
        // Oder mit Supplier:
        List<ArrayList<String>> lists2 = Collections.nCopies(3, null).stream()
            .map(ArrayList::new) // () -> new ArrayList()
            .collect(Collectors.toList());
    }
}

Constructor References mit Parametern

Für Konstruktoren mit Argumenten benötigen Sie ein passendes Functional Interface:

@FunctionalInterface
interface StringListFactory {
    List<String> create(int initialCapacity);
}

StringListFactory factory = ArrayList::new; // ArrayList(int)
List<String> list = factory.create(100);

Method References in Streams

List<String> list = List.of("a", "bb", "ccc");

// map: Instanzmethode beliebigen Objekts
list.stream().map(String::length).forEach(System.out::println); // 1, 2, 3

// filter: Prädikat als Method Reference (static)
list.stream().filter(StringUtils::isNotBlank).collect(Collectors.toList());

// sort: Comparator via Method Reference
list.stream().sorted(Comparator.comparing(String::length)).collect(Collectors.toList());

Wann Method Reference, wann Lambda?

• Method Reference: Wenn Sie nur eine existierende Methode delegieren – kürzer, klarer, intent-revealing.
• Lambda: Wenn Logik kombiniert, transformiert oder neu ist (x -> x * 2 + 1).

Fazit

Method References sind syntaktischer Zucker für häufige Lambda-Patterns. Sie verbessern Lesbarkeit und machen funktionalen Code noch deklarativer. Beherrschen Sie die vier Formen – sie sind allgegenwärtig in modernem Java-Code.