Java Function Functional Interface

Function<T, R> ist das funktionale Interface für die Frage "Wandle dieses T in ein R um" — eine Eingabe, eine Ausgabe, keine Seiteneffekte erwartet. Es ist die Form, die Stream.map annimmt, die Form, die Optional.map annimmt, die Form, die Map.computeIfAbsent annimmt, und die Form, die jede JDK-Methode akzeptiert, die "transformiere dies in jenes" bedeutet. Eine einzige abstrakte Methode, drei oder vier nützliche Default-Methoden und eine kleine Algebra (andThen, compose, identity) zum Verknüpfen von Transformationen, ohne Zwischen-Lambdas schreiben zu müssen.

Das Interface

@FunctionalInterface
public interface Function<T, R> {
  R apply(T t);                                                    // the only abstract method

  default <V> Function<V, R> compose(Function<? super V, ? extends T> before);
  default <V> Function<T, V> andThen(Function<? super R, ? extends V> after);
  static  <T> Function<T, T> identity();
}

apply(T) ist die SAM (single abstract method). Jedes Lambda oder jeder Methodenverweis, der an einer Function<T, R>-Position landet, implementiert sie.

Function<String, Integer> length = String::length;
int n = length.apply("hello");                  // 5

Normalerweise lässt man stream.map(length) oder optional.map(length) apply für sich aufrufen. Der Methodenname ist wichtig, wenn man Code schreibt, der eine Function<T, R> entgegennimmt und sie einmal aufrufen muss.

`andThen` und `compose` — zwei Wege zum Verketten

Die beiden Default-Methoden erstellen eine neue Function, indem sie den Empfänger mit einer anderen verknüpfen. Sie unterscheiden sich nur in der Richtung:

Function<String, String>  trim     = String::trim;
Function<String, Integer> length   = String::length;

Function<String, Integer> trimThenLength = trim.andThen(length);     // f.andThen(g): g(f(x))
Function<String, Integer> sameThing      = length.compose(trim);     // g.compose(f): g(f(x))

Beide erzeugen die gleiche Pipeline s -> length(trim(s)). Der Unterschied liegt darin, welche sich an der Aufrufstelle besser liest:

andThen liest sich von links nach rechts, in derselben Reihenfolge, in der die Daten fließen. trim.andThen(length).andThen(asString) bedeutet "trimmen, dann Länge, dann asString."
compose liest sich von rechts nach links, so wie mathematische Komposition geschrieben wird: f ∘ g bedeutet "wende g zuerst an, dann f." length.compose(trim) bedeutet "length nach trim."

Im Anwendungscode ist andThen fast immer die klarere Wahl — Code liest sich von oben nach unten, von links nach rechts, und eine links-nach-rechts-Pipeline passt dazu. compose ist nützlich, wenn man eine abschließende Funktion hat und Vorverarbeitung voranstellen möchte, ohne die Kette neu zu schreiben.

Beide sind in dem Sinne lazy, dass sie beim Kompositionszeitpunkt nichts ausführen; sie produzieren lediglich eine neue Function, deren apply die zugrunde liegenden in der richtigen Reihenfolge aufruft.

`Function.identity()` — die Keine-Operation-Transformation

Function<T, T> id = Function.identity();      // t -> t

identity() gibt bei jedem Aufruf dieselbe Instanz zurück (ein Singleton-Lambda), sodass es keine Allokationskosten hat. Die einzige Stelle, an der es sich bewährt, ist als Schlüssel- oder Wert-Mapper in Collectors.toMap, wo man eine Function übergeben muss, auch wenn der Wert "das Element selbst" ist:

Map<String, Person> byName = people.stream()
    .collect(Collectors.toMap(Person::name, Function.identity()));   // key=name, value=person

Ohne Function.identity() würde man p -> p schreiben, was bei jedem Aufruf ein neues Lambda allokiert und sich schlechter liest.

Ein subtiler Punkt: identity() funktioniert nur, wenn Eingabe- und Ausgabetyp identisch sind. Sobald ein generischer Typ erweitert wird (Function<? super T, ? extends R>), kann der Compiler einen dazu zwingen, erneut ein Lambda auszuschreiben. Das ist ein Randfall, aber es lohnt sich, ihn zu kennen, wenn generische Typinferenz sich beschwert.

`Function<T, R>` versus `UnaryOperator<T>`

UnaryOperator<T> ist die Spezialisierung für den Fall, dass Eingabe und Ausgabe denselben Typ haben:

UnaryOperator<String> upper = String::toUpperCase;       // String -> String
Function<String, String> sameShape = String::toUpperCase;

Beide sind gültige Function<String, String>-Instanzen — UnaryOperator<T> erweitert Function<T, T>. Der Unterschied liegt auf API-Ebene: List.replaceAll, Map.replaceAll und Comparator.thenComparing(UnaryOperator) deklarieren UnaryOperator<T>, weil "ersetze jedes Element durch einen transformierten Wert desselben Typs" genau diese Form hat. Übergibt man einen Methodenverweis, wählt der Compiler den richtigen.

`BiFunction<T, U, R>` — zwei Eingaben

Die Zwei-Argument-Form:

BiFunction<String, Integer, String> repeat = String::repeat;
String s = repeat.apply("ab", 3);             // "ababab"

BiFunction hat dasselbe andThen, aber kein compose — die Asymmetrie ist beabsichtigt, weil das Vorverarbeiten einer Zwei-Argument-Funktion zwei compose-Parameter erfordern würde.

Das JDK verwendet BiFunction<K, V, V> für Map.merge und BiFunction<K, V, V_NEW> für Map.compute. BinaryOperator<T> ist der Sonderfall, bei dem alle drei Typparameter T sind (Eingabe, Eingabe und Ausgabe alle gleich) — behandelt im BinaryOperator-Kapitel.

Primitive Spezialisierungen — drei Familien

Function<Integer, String> boxed das int bei jedem Aufruf. Das Paket liefert drei Familien, um das zu vermeiden:

// 1. Primitive in, object out — "IntFunction<R>"
IntFunction<String>     fromInt   = i -> "n=" + i;

// 2. Object in, primitive out — "ToIntFunction<T>"
ToIntFunction<String>   strLen    = String::length;
ToDoubleFunction<Item>  price     = Item::price;

// 3. Primitive in, primitive out — "IntToLongFunction", "IntUnaryOperator", etc.
IntToLongFunction       square    = i -> (long) i * i;
IntUnaryOperator        doubleIt  = i -> i * 2;
DoubleUnaryOperator     halve     = d -> d / 2.0;

Die Benennung liest sich wie ein Satz:

IntX — operiert auf einem int.
ToIntX — produziert ein int.
IntToLongX — int rein, long raus.

Stream.mapToInt(ToIntFunction) ist die Brücke von einem gebündelten Stream<T> in einen IntStream. Sobald man auf einem IntStream ist, verwendet jede Transformation IntUnaryOperator oder IntToLongFunction — und die Boxing-Kosten bleiben bei null.

Ein ausgearbeitetes Beispiel: Komposition, Identity und eine primitive Spezialisierung

Das Programm unten erstellt zwei Functions, verknüpft sie mit sowohl andThen als auch compose, um zu zeigen, dass sie äquivalent sind, verwendet Function.identity() innerhalb eines Collectors.toMap und stellt eine gebündelte Function<Integer, Integer> einer primitiven IntUnaryOperator bei einer ausreichend großen Arbeitslast gegenüber, um die Boxing-Kosten zu spüren.

java— editable, runs on the server

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class FunctionShowcase {
  record Person(String name, int age) {}

public static void main(String[] args) {
    // --- basics ---
    Function<String, Integer> length = String::length;
    System.out.println("length(\"hello\") = " + length.apply("hello"));

// --- andThen vs compose: same pipeline, different reading order ---
    Function<String, String>  trim     = String::trim;
    Function<String, String>  upper    = String::toUpperCase;

Function<String, String>  chainA   = trim.andThen(upper);
    Function<String, String>  chainB   = upper.compose(trim);
    System.out.println("\nandThen(\"  hi \") = '" + chainA.apply("  hi ") + "'");
    System.out.println("compose(\"  hi \") = '" + chainB.apply("  hi ") + "'");

// --- longer chain, type changes along the way ---
    Function<String, Integer> trimLenChain = trim.andThen(upper).andThen(length);
    System.out.println("trim.andThen(upper).andThen(length)(\"  hi \") = "
        + trimLenChain.apply("  hi "));

// --- identity() inside Collectors.toMap ---
    List<Person> people = List.of(
        new Person("Alice", 30),
        new Person("Bob",   25),
        new Person("Carol", 40));
    Map<String, Person> byName = people.stream()
        .collect(Collectors.toMap(Person::name, Function.identity()));
    System.out.println("\nbyName(\"Bob\") = " + byName.get("Bob"));

// --- BiFunction.andThen ---
    BiFunction<String, Integer, String> repeat = String::repeat;
    Function<String, Integer>           hash   = Object::hashCode;
    BiFunction<String, Integer, Integer> repeatedHash = repeat.andThen(hash);
    System.out.println("\nrepeatedHash(\"ab\", 3) = " + repeatedHash.apply("ab", 3));

// --- boxed Function<Integer,Integer> vs IntUnaryOperator ---
    int N = 5_000_000;

long t1 = System.nanoTime();
    Function<Integer, Integer> squareBoxed = n -> n * n;
    long sumBoxed = IntStream.rangeClosed(1, N).boxed()
        .mapToLong(n -> squareBoxed.apply(n)).sum();
    long durBoxed = System.nanoTime() - t1;

long t2 = System.nanoTime();
    IntUnaryOperator squareInt = n -> n * n;
    long sumInt = IntStream.rangeClosed(1, N).map(squareInt).asLongStream().sum();
    long durInt = System.nanoTime() - t2;

System.out.println("\n--- summary ---");
    System.out.printf("Function<Integer,Integer>: sum=%d  time=%d ms%n",
        sumBoxed, durBoxed / 1_000_000);
    System.out.printf("IntUnaryOperator:           sum=%d  time=%d ms%n",
        sumInt,   durInt   / 1_000_000);
  }
}

Was man aus dem Lauf mitnehmen kann:

trim.andThen(upper) und upper.compose(trim) produzierten denselben String aus derselben Eingabe. Sie unterscheiden sich nur darin, welcher Name natürlich liest, wo man ihn schreibt — andThen passt zum links-nach-rechts-Datenfluss, compose passt zur mathematischen "f nach g"-Notation.
Die längere Kette trim.andThen(upper).andThen(length) änderte den Ausgabetyp von String zu Integer unterwegs. Die Pipeline setzt sich typsicher zusammen; der Compiler hat String -> String -> String -> Integer für einen nachverfolgt.
Function.identity() passte als Wert-Mapper in Collectors.toMap(Person::name, Function.identity()). Das Lambda p -> p hätte funktioniert, aber identity() ist die Singleton-Variante ohne Allokation und liest sich als Absicht ("der Wert ist die Person").
Die gebündelte Function<Integer, Integer> zahlt bei jedem Aufruf für zwei Integer-Boxings; der primitive IntUnaryOperator zahlt nichts. Ein einzelner aufgewärmter Lauf kann ähnliche Zeiten zeigen — der JIT ist gut darin, kurzlebige Boxes zu eliminieren — aber unter realem Allokationsdruck (große Heaps, gleichzeitige GC, entweichende Werte) ist die primitive Variante die, die standhält. Greife darauf in heißen Pipelines zurück, die Millionen von Werten verarbeiten.
BiFunction.andThen(Function) verknüpfte eine Zwei-Argument-Funktion mit einer Ein-Argument-Fortsetzung. Es gibt kein BiFunction.compose — das Vorverarbeiten von zwei Eingaben würde zwei compose-Argumente erfordern, was die API bewusst vermeidet.

Was kommt als Nächstes

Function<T, R> und Predicate<T> sind beide reine Formen — Eingabe, Ausgabe, keine erwarteten Seiteneffekte. Das nächste Kapitel, Java Consumer und Supplier, behandelt die beiden Interfaces, die über diese Reinheit hinausgehen: Consumer<T> nimmt eine Eingabe und produziert nichts (einen Seiteneffekt — drucken, loggen, speichern), und Supplier<T> nimmt nichts und produziert eine Ausgabe (lazy Default, Factory, Zufälligkeit). Sie vervollständigen die Vier-Ecken-Taxonomie, die man in der Übersicht der eingebauten Interfaces gesehen hat.

Übungen

Übung

Du hast `Function<String, String> trim = String::trim;` und `Function<String, Integer> length = String::length;`. Du möchtest eine `Function<String, Integer>`, die zuerst trimmt und dann die Länge nimmt. Welcher Ausdruck erstellt sie am natürlichsten?

`trim.andThen(length)` — `andThen` liest sich von links nach rechts, passend zum Datenfluss trim → length`trim.compose(length)` — `compose` wendet das Argument nach dem Empfänger an`length.andThen(trim)` — dies trimmt nach dem Messen der Länge`Function.identity().andThen(trim).compose(length)` — die explizite Identity ist für typenübergreifende Ketten erforderlich

Das Interface

andThen und compose — zwei Wege zum Verketten

Function.identity() — die Keine-Operation-Transformation

Function<T, R> versus UnaryOperator<T>

BiFunction<T, U, R> — zwei Eingaben