Leer Bi-versies van functionele interfaces | Fundamenten en Functionele Mogelijkheden van Stream API

In Java zijn er verschillende bi-versies van functionele interfaces die werken met twee argumenten. Deze interfaces bieden handige sjablonen voor het uitvoeren van diverse bewerkingen met een paar invoergegevens, of het nu gaat om het berekenen van een resultaat, het uitvoeren van een actie of het controleren van een voorwaarde.

Ze vereenvoudigen het werken met complexe scenario's waarin je met twee parameters tegelijk moet werken.

In plaats van omvangrijke code te schrijven met meerdere geneste aanroepen, kun je gebruikmaken van beknopte interfaces die kant-en-klare methoden bieden voor het implementeren van belangrijke functionaliteiten.

BiFunction<T, U, R>

BiFunction is een functionele interface die twee invoerargumenten van de types T en U accepteert en een resultaat van het type R retourneert.

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

BiFunction is ideaal voor taken waarbij twee waarden moeten worden verwerkt en een afgeleid resultaat wordt teruggegeven, zoals berekening, transformatie of gegevenscombinatie.

Bijvoorbeeld, wanneer het nodig is om de totale kosten van artikelen op voorraad te berekenen door de hoeveelheid te vermenigvuldigen met de prijs per eenheid:

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 dit voorbeeld accepteert BiFunction<Integer, Double, Double> twee argumenten: quantity en pricePerUnit (prijs per eenheid), en retourneert het resultaat — de totale kosten als een Double-waarde. De methode apply() voert de gespecificeerde bewerking uit en koppelt de functionele interface aan de vermenigvuldigingslogica.

BiConsumer<T, U>

BiConsumer is een functionele interface die twee argumenten van de typen T en U accepteert, maar geen resultaat retourneert.

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

Wordt gebruikt voor handelingen uitvoeren op twee objecten, zoals loggen, informatie tonen of gegevens opslaan.

Bijvoorbeeld, een functionele interface maken die de naam van een werknemer en het salaris accepteert, de gegevens formatteert en naar de console print:

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 dit voorbeeld wordt BiConsumer<String, Double> gebruikt om de naam van de werknemer en het salaris te verwerken, waarbij de gegevens op een geformatteerde manier naar de console worden geprint.

De forEach()-methode van de Map-collectie geeft elk key-value-paar door aan de BiConsumer, die de gespecificeerde handeling uitvoert voor alle werknemers.

BiPredicate<T, U>

BiPredicate is een functionele interface die twee argumenten van de types T en U accepteert en een boolean resultaat retourneert.

@FunctionalInterface
public interface BiPredicate<T, U> {
    boolean test(T t, U u);
}

Wordt gebruikt voor het controleren van voorwaarden waarbij het resultaat een boolean waarde is (true of false), gebaseerd op de analyse van twee invoerwaarden.

Bijvoorbeeld, controleren of de lengte van een string groter is dan een gegeven getal:

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 dit voorbeeld accepteert BiPredicate<String, Integer> twee argumenten: de string str en het getal length, dat de minimale lengte vertegenwoordigt. De methode test() controleert de voorwaarde en retourneert true als de lengte van de string groter is dan het opgegeven getal, of anders false.

1. Welke methode is de belangrijkste in de interface `BiFunction<T, U, R>`?

2. Wat retourneert de methode `accept(T t, U u)` van de interface `BiConsumer<T, U>`?

3. Welke interface wordt gebruikt om een logische conditie met twee argumenten te controleren?

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 1. Hoofdstuk 13

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Suggested prompts:

Can you give examples of how to use these bi-functional interfaces in Java?

What are some common use cases for BiFunction, BiConsumer, and BiPredicate?

How do these bi-interfaces differ from their single-argument counterparts?

Awesome!

Completion rate improved to 2.33

Veeg om het menu te tonen

Ze vereenvoudigen het werken met complexe scenario's waarin je met twee parameters tegelijk moet werken.

BiFunction<T, U, R>

BiFunction is een functionele interface die twee invoerargumenten van de types T en U accepteert en een resultaat van het type R retourneert.

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

Bijvoorbeeld, wanneer het nodig is om de totale kosten van artikelen op voorraad te berekenen door de hoeveelheid te vermenigvuldigen met de prijs per eenheid:

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 is een functionele interface die twee argumenten van de typen T en U accepteert, maar geen resultaat retourneert.

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T t, U u);
}

Wordt gebruikt voor handelingen uitvoeren op twee objecten, zoals loggen, informatie tonen of gegevens opslaan.

Bijvoorbeeld, een functionele interface maken die de naam van een werknemer en het salaris accepteert, de gegevens formatteert en naar de console print:

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

De forEach()-methode van de Map-collectie geeft elk key-value-paar door aan de BiConsumer, die de gespecificeerde handeling uitvoert voor alle werknemers.

BiPredicate<T, U>

BiPredicate is een functionele interface die twee argumenten van de types T en U accepteert en een boolean resultaat retourneert.

@FunctionalInterface
public interface BiPredicate<T, U> {
    boolean test(T t, U u);
}

Wordt gebruikt voor het controleren van voorwaarden waarbij het resultaat een boolean waarde is (true of false), gebaseerd op de analyse van twee invoerwaarden.

Bijvoorbeeld, controleren of de lengte van een string groter is dan een gegeven getal:

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. Welke methode is de belangrijkste in de interface `BiFunction<T, U, R>`?

2. Wat retourneert de methode `accept(T t, U u)` van de interface `BiConsumer<T, U>`?

3. Welke interface wordt gebruikt om een logische conditie met twee argumenten te controleren?

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 1. Hoofdstuk 13

Bi-versies van functionele interfaces

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Welke methode is de belangrijkste in de interface BiFunction<T, U, R>?

2. Wat retourneert de methode accept(T t, U u) van de interface BiConsumer<T, U>?

3. Welke interface wordt gebruikt om een logische conditie met twee argumenten te controleren?

Awesome!

Bi-versies van functionele interfaces

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Welke methode is de belangrijkste in de interface BiFunction<T, U, R>?

2. Wat retourneert de methode accept(T t, U u) van de interface BiConsumer<T, U>?

3. Welke interface wordt gebruikt om een logische conditie met twee argumenten te controleren?

1. Welke methode is de belangrijkste in de interface `BiFunction<T, U, R>`?

2. Wat retourneert de methode `accept(T t, U u)` van de interface `BiConsumer<T, U>`?

1. Welke methode is de belangrijkste in de interface `BiFunction<T, U, R>`?

2. Wat retourneert de methode `accept(T t, U u)` van de interface `BiConsumer<T, U>`?