Lernen Bi-Versionen Funktionaler Schnittstellen | Grundlagen und Funktionale Möglichkeiten der Stream-API

In Java existieren mehrere bi-Versionen von funktionalen Schnittstellen, die mit zwei Argumenten arbeiten. Diese Schnittstellen bieten praktische Vorlagen, um verschiedene Operationen mit einem Paar von Eingabedaten durchzuführen, sei es zur Berechnung eines Ergebnisses, zur Ausführung einer Aktion oder zur Ü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 Sie von prägnanten Schnittstellen profitieren, 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 optimal 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


              1234567891011121314151617
            
package 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, um Aktionen an zwei Objekten auszuführen, wie zum Beispiel Protokollierung, Anzeige von Informationen oder Speichern von Daten.

Beispielsweise kann eine funktionale Schnittstelle erstellt werden, die den Namen eines Mitarbeiters und das Gehalt entgegennimmt, die Daten formatiert und in der Konsole ausgibt:

Main.java


              1234567891011121314151617181920212223242526
            
package 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);
}

Es wird verwendet, um Bedingungen zu überprüfen, bei denen das Ergebnis ein boolescher Wert (true oder false) ist, basierend auf der Analyse von zwei Eingabewerten.

Beispielsweise kann überprüft werden, ob die Länge eines Strings größer als eine angegebene Zahl ist:

Main.java


              1234567891011121314151617
            
package 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?

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 13

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Awesome!

Completion rate improved to 2.33

Swipe um das Menü anzuzeigen

Sie vereinfachen die Handhabung komplexer Szenarien, in denen mit zwei Parametern gleichzeitig gearbeitet werden muss.

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);
}

Beispielsweise, wenn der Gesamtpreis von Artikeln im Lager berechnet werden soll, indem die Menge mit dem Stückpreis multipliziert wird:

Main.java


              1234567891011121314151617
            
package 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);
    }
}

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, um Aktionen an zwei Objekten auszuführen, wie zum Beispiel Protokollierung, Anzeige von Informationen oder Speichern von Daten.

Beispielsweise kann eine funktionale Schnittstelle erstellt werden, die den Namen eines Mitarbeiters und das Gehalt entgegennimmt, die Daten formatiert und in der Konsole ausgibt:

Main.java


              1234567891011121314151617181920212223242526
            
package 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);
}

Es wird verwendet, um Bedingungen zu überprüfen, bei denen das Ergebnis ein boolescher Wert (true oder false) ist, basierend auf der Analyse von zwei Eingabewerten.

Beispielsweise kann überprüft werden, ob die Länge eines Strings größer als eine angegebene Zahl ist:

Main.java


              1234567891011121314151617
            
package 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);
    }
}

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?

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 13

Bi-Versionen Funktionaler Schnittstellen

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

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?

Awesome!

Bi-Versionen Funktionaler Schnittstellen

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

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?

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?

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?