Bi-Versionen von Funktionalen Schnittstellen
Swipe um das Menü anzuzeigen
In Java gibt es mehrere bi-Versionen von funktionalen Schnittstellen, die mit zwei Argumenten arbeiten. Diese Schnittstellen bieten praktische Vorlagen für verschiedene Operationen mit einem Paar von Eingabedaten, sei es zur Berechnung eines Ergebnisses, Ausführung einer Aktion oder Überprüfung einer Bedingung.
Sie vereinfachen die Handhabung komplexer Szenarien, in denen mit zwei Parametern gleichzeitig gearbeitet werden muss.
Anstatt beispielsweise umfangreichen Code mit mehreren verschachtelten Aufrufen zu schreiben, können prägnante Schnittstellen genutzt werden, die vorgefertigte Methoden zur Implementierung zentraler Funktionalitäten bereitstellen.
BiFunction<T, U, R>
BiFunction ist eine funktionale Schnittstelle, die zwei Eingabeargumente der Typen T und U entgegennimmt und ein Ergebnis vom Typ R zurückgibt.
@FunctionalInterface
public interface BiFunction<T, U, R> {
R apply(T t, U u);
}
BiFunction ist ideal für Aufgaben, bei denen zwei Werte verarbeitet und ein abgeleitetes Ergebnis zurückgegeben werden, wie etwa Berechnung, Transformation oder Datenkombination.
Beispielsweise, wenn der Gesamtpreis von Artikeln im Lager berechnet werden soll, indem die Menge mit dem Stückpreis multipliziert wird:
Main.java
1234567891011121314151617package com.example; import java.util.function.BiFunction; public class Main { public static void main(String[] args) { // `BiFunction` to calculate total cost BiFunction<Integer, Double, Double> calculateTotalCost = (quantity, pricePerUnit) -> quantity * pricePerUnit; // Example usage int quantity = 50; double pricePerUnit = 19.99; double totalCost = calculateTotalCost.apply(quantity, pricePerUnit); System.out.println("Total cost: $" + totalCost); } }
In diesem Beispiel akzeptiert BiFunction<Integer, Double, Double> zwei Argumente: quantity und pricePerUnit (Preis pro Einheit) und gibt das Ergebnis zurück – die Gesamtkosten als Double-Wert. Die Methode apply() führt die angegebene Operation aus und verbindet das funktionale Interface mit der Multiplikationslogik.
BiConsumer<T, U>
BiConsumer ist ein funktionales Interface, das zwei Argumente der Typen T und U entgegennimmt, aber kein Ergebnis zurückgibt.
@FunctionalInterface
public interface BiConsumer<T, U> {
void accept(T t, U u);
}
Wird verwendet für Aktionen mit zwei Objekten, wie Protokollierung, Anzeige von Informationen oder Speichern von Daten.
Beispielsweise lässt sich eine funktionale Schnittstelle erstellen, die den Namen eines Mitarbeiters und das Gehalt entgegennimmt, die Daten formatiert und in der Konsole ausgibt:
Main.java
1234567891011121314151617181920212223242526package com.example; import java.util.HashMap; import java.util.Map; import java.util.function.BiConsumer; public class Main { public static void main(String[] args) { // `BiConsumer` for formatted output of employee details BiConsumer<String, Double> printEmployeeDetails = (name, salary) -> { System.out.printf("Employee: %-15s | Salary: $%.2f%n", name, salary); }; // Collection of employees with their salaries Map<String, Double> employeeData = new HashMap<>(); employeeData.put("John Smith", 75000.0); employeeData.put("Mary Johnson", 82000.0); employeeData.put("Robert Brown", 64000.0); employeeData.put("Emily Davis", 91000.0); // Print details of each employee System.out.println("Employee Salary Report:"); System.out.println("-----------------------------------"); employeeData.forEach(printEmployeeDetails); } }
In diesem Beispiel wird BiConsumer<String, Double> verwendet, um den Namen des Mitarbeiters und das Gehalt zu verarbeiten und die Daten formatiert in der Konsole auszugeben.
Die Methode forEach() der Map-Kollektion übergibt jedes Schlüssel-Wert-Paar an den BiConsumer, der die angegebene Aktion für alle Mitarbeiter ausführt.
BiPredicate<T, U>
BiPredicate ist ein funktionales Interface, das zwei Argumente der Typen T und U entgegennimmt und ein boolesches Ergebnis zurückgibt.
@FunctionalInterface
public interface BiPredicate<T, U> {
boolean test(T t, U u);
}
Wird verwendet zur Überprüfung von Bedingungen, bei denen das Ergebnis ein boolescher Wert (true oder false) ist, basierend auf der Analyse von zwei Eingabewerten.
Beispielsweise lässt sich prüfen, ob die Länge eines Strings größer als eine angegebene Zahl ist:
Main.java
1234567891011121314151617package com.example; import java.util.function.BiPredicate; public class Main { public static void main(String[] args) { // `BiPredicate` to check if string length is greater than given number BiPredicate<String, Integer> isStringLongerThan = (str, length) -> str.length() > length; // Example usage String text = "Sample string"; int minLength = 10; boolean result = isStringLongerThan.test(text, minLength); System.out.println("String is longer than " + minLength + " characters: " + result); } }
In diesem Beispiel akzeptiert BiPredicate<String, Integer> zwei Argumente: den String str und die Zahl length, die die Mindestlänge darstellt. Die Methode test() prüft die Bedingung und gibt true zurück, wenn die Länge des Strings größer als die angegebene Zahl ist, andernfalls false.
1. Welche Methode ist die Hauptmethode im Interface BiFunction<T, U, R>?
2. Was gibt die Methode accept(T t, U u) des Interfaces BiConsumer<T, U> zurück?
3. Welches Interface wird verwendet, um eine logische Bedingung mit zwei Argumenten zu prüfen?
Danke für Ihr Feedback!
Fragen Sie AI
Fragen Sie AI
Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen
