0Pricing
Java Academy · Lektion

Function und BiFunction

Werte funktional transformieren

Function und BiFunction ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Wofür Function steht

Function<T, R> ist die zentrale Transformationsschnittstelle in java.util.function. Sie nimmt ein Argument vom Typ T entgegen und gibt ein Ergebnis vom Typ R zurück.

  • Ihre einzige abstrakte Methode ist R apply(T t).
  • Sie modelliert eine reine Abbildung von der Eingabe zur Ausgabe.
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = s -> s.length();
        System.out.println(length.apply("hello"));
    }
}

apply aufrufen

Sie rufen eine Function auf, indem Sie apply aufrufen. Der Lambda-Rumpf enthält die Transformationslogik.

  • Eingabe- und Ausgabetyp können sich unterscheiden.
  • Eine Methodenreferenz wie String::toUpperCase kann ein Lambda ersetzen.
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> upper = String::toUpperCase;
        System.out.println(upper.apply("java"));
    }
}

andThen-Komposition

andThen verkettet Funktionen: Das Ergebnis der ersten Funktion wird zur Eingabe der zweiten.

  • f.andThen(g) bedeutet g(f(x)).
  • Die Schreibweise wird von links nach rechts gelesen.
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.andThen(plus3).apply(5));
    }
}

compose-Komposition

compose führt zuerst die Argumentfunktion aus.

  • f.compose(g) bedeutet f(g(x)).
  • Es ist das Gegenstück zu andThen.
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.compose(plus3).apply(5));
    }
}

Function.identity

Function.identity() gibt eine Funktion zurück, die ihre Eingabe unverändert zurückgibt.

  • Nützlich in Stream-Collectoren und Standardzuordnungen.
  • Entspricht x -> x.
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> id = Function.identity();
        System.out.println(id.apply("unchanged"));
    }
}

BiFunction kennenlernen

BiFunction<T, U, R> nimmt zwei Argumente entgegen und gibt ein Ergebnis zurück.

  • Ihre Methode ist R apply(T t, U u).
  • Ideal zum Kombinieren zweier Werte, etwa beim Zusammenführen von Maps.
import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(4, 6));
    }
}

BiFunction mit unterschiedlichen Typen

Die drei Typparameter von BiFunction können sich alle unterscheiden.

  • Hier werden ein String und ein int zu einem String kombiniert.
import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<String, Integer, String> repeat = (s, n) -> s.repeat(n);
        System.out.println(repeat.apply("ab", 3));
    }
}

BiFunction und andThen

BiFunction unterstützt ebenfalls andThen. Dabei wird eine einargumentige Function verwendet, um das Ergebnis nachträglich zu verarbeiten.

  • Bei BiFunction gibt es kein compose, da dafür zwei Eingaben erforderlich wären.
import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        Function<Integer, String> label = n -> "sum=" + n;
        System.out.println(add.andThen(label).apply(7, 8));
    }
}

Funktionen in Collections

Viele APIs akzeptieren eine Function. Beispielsweise nimmt Map.computeIfAbsent eine Mapping-Funktion für fehlende Schlüssel entgegen.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> lengths = new HashMap<>();
        lengths.computeIfAbsent("hello", String::length);
        System.out.println(lengths);
    }
}

Funktionen in Variablen speichern

Da Funktionen Objekte sind, können Sie sie speichern, übergeben und zurückgeben. Das bildet die Grundlage des funktionalen Java-Stils.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> square = n -> n * n;
        Function<Integer, Integer> cube = n -> n * n * n;
        Function<Integer, Integer> chosen = square;
        System.out.println(chosen.apply(5));
    }
}

Eine Pipeline aufbauen

Durch wiederholtes Verketten mit andThen entsteht eine gut lesbare und wiederverwendbare Transformationspipeline.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> trim = String::trim;
        Function<String, String> upper = String::toUpperCase;
        Function<String, Integer> len = String::length;
        System.out.println(trim.andThen(upper).andThen(len).apply("  abc "));
    }
}

Kurzer Test

Was berechnet f.andThen(g).apply(x)?

Zusammenfassung

Sie haben die zentralen Transformationsschnittstellen gelernt:

  • Function<T,R> bildet mit apply einen Wert auf einen anderen ab.
  • andThen verkettet vorwärts (g(f(x)); compose verkettet rückwärts (f(g(x))).
  • Function.identity() gibt die Eingabe zurück.
  • BiFunction<T,U,R> verarbeitet zwei Eingaben und unterstützt andThen, aber nicht compose.

Häufig gestellte Fragen

Ist die Lektion „Function und BiFunction“ kostenlos?

Ja — der vollständige Text von „Function und BiFunction“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Function und BiFunction“?

Werte funktional transformieren Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Function und BiFunction“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Function und BiFunction
  2. Supplier und Consumer
  3. Predicate und Komposition
  4. Benutzerdefinierte funktionale Interfaces
← Zurück zu Java Academy