Bi-versies van functionele interfaces
Veeg om het menu te tonen
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 handeling of het controleren van een voorwaarde.
Ze vereenvoudigen het omgaan met complexe scenario's waarin met twee parameters tegelijk gewerkt moet worden.
In plaats van omvangrijke code te schrijven met meerdere geneste aanroepen, kan gebruik worden gemaakt 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, als het nodig is om de totale kosten van artikelen op voorraad te berekenen door de hoeveelheid te vermenigvuldigen met de prijs per stuk:
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 dit voorbeeld accepteert BiFunction<Integer, Double, Double> twee argumenten: quantity en pricePerUnit (prijs per eenheid), en geeft het resultaat terug — de totale kosten als een Double-waarde. De methode apply() voert de gespecificeerde bewerking uit, waarbij de functionele interface wordt gekoppeld 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 het uitvoeren van acties op twee objecten, zoals loggen, informatie weergeven of gegevens opslaan.
Bijvoorbeeld, laten we een functionele interface maken die een naam van een werknemer en salaris accepteert, de gegevens formatteert en naar de console print:
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 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 methode forEach() van de Map-collectie geeft elk key-value pair door aan de BiConsumer, die de gespecificeerde actie 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
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 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 false in het andere geval.
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?
Bedankt voor je feedback!
Vraag AI
Vraag AI
Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.
