Lære Bi-versioner af Funktionelle Grænseflader | Grundlæggende og Funktionelle Kapaciteter af Stream API

I Java findes der flere bi-versioner af funktionelle interfaces, som arbejder med to argumenter. Disse interfaces giver praktiske skabeloner til at udføre forskellige operationer med et par af inputdata, uanset om det drejer sig om at beregne et resultat, udføre en handling eller kontrollere en betingelse.

De forenkler håndteringen af komplekse scenarier, hvor der skal arbejdes med to parametre samtidigt.

I stedet for at skrive omfangsrig kode med flere indlejrede kald, kan du fordele dig af koncise interfaces, der tilbyder færdiglavede metoder til implementering af centrale funktionaliteter.

BiFunction<T, U, R>

BiFunction er et funktionelt interface, der tager to inputargumenter af typerne T og U, og returnerer et resultat af typen R.

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

BiFunction er ideel til opgaver, hvor to værdier skal behandles og et afledt resultat returneres, såsom beregning, transformation eller datakombination.

For eksempel, hvis det er nødvendigt at beregne de samlede omkostninger for varer på lager ved at multiplicere mængden med prisen pr. enhed:

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

I dette eksempel accepterer BiFunction<Integer, Double, Double> to argumenter: quantity og pricePerUnit (pris pr. enhed), og returnerer resultatet — samlet pris som en Double-værdi. Metoden apply() udfører den specificerede operation, der forbinder funktionsinterfacet med multiplikationslogikken.

BiConsumer<T, U>

BiConsumer er et funktionsinterface, der tager to argumenter af typerne T og U, men returnerer ikke et resultat.

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

Anvendes til udførelse af handlinger på to objekter, såsom logning, visning af information eller lagring af data.

For eksempel kan der oprettes et funktionelt interface, der modtager en medarbejders navn og løn, formaterer dataene og udskriver dem til konsollen:

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

I dette eksempel anvendes BiConsumer<String, Double> til at behandle medarbejderens navn og løn, hvor dataene udskrives til konsollen i et formateret format.

Metoden forEach() fra Map-samlingen sender hvert nøgle-værdi-par til BiConsumer, som udfører den specificerede handling for alle medarbejdere.

BiPredicate<T, U>

BiPredicate er et funktionelt interface, der tager to argumenter af typerne T og U og returnerer et boolesk resultat.

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

Det bruges til at kontrollere betingelser, hvor resultatet er en boolesk værdi (true eller false), baseret på analyse af to inputværdier.

For eksempel kan man kontrollere, om længden af en streng er større end et givet tal:

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

I dette eksempel accepterer BiPredicate<String, Integer> to argumenter: strengen str og tallet length, som repræsenterer minimumslængden. Metoden test() kontrollerer betingelsen og returnerer true, hvis strengens længde er større end det angivne tal, ellers false.

1. Hvilken metode er den primære i interfacet `BiFunction<T, U, R>`?

2. Hvad returnerer metoden `accept(T t, U u)` i interfacet `BiConsumer<T, U>`?

3. Hvilket interface bruges til at kontrollere en logisk betingelse med to argumenter?

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 13

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Awesome!

Completion rate improved to 2.33

Stryg for at vise menuen

De forenkler håndteringen af komplekse scenarier, hvor der skal arbejdes med to parametre samtidigt.

BiFunction<T, U, R>

BiFunction er et funktionelt interface, der tager to inputargumenter af typerne T og U, og returnerer et resultat af typen R.

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

BiFunction er ideel til opgaver, hvor to værdier skal behandles og et afledt resultat returneres, såsom beregning, transformation eller datakombination.

For eksempel, hvis det er nødvendigt at beregne de samlede omkostninger for varer på lager ved at multiplicere mængden med prisen pr. enhed:

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 er et funktionsinterface, der tager to argumenter af typerne T og U, men returnerer ikke et resultat.

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

Anvendes til udførelse af handlinger på to objekter, såsom logning, visning af information eller lagring af data.

For eksempel kan der oprettes et funktionelt interface, der modtager en medarbejders navn og løn, formaterer dataene og udskriver dem til konsollen:

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

I dette eksempel anvendes BiConsumer<String, Double> til at behandle medarbejderens navn og løn, hvor dataene udskrives til konsollen i et formateret format.

Metoden forEach() fra Map-samlingen sender hvert nøgle-værdi-par til BiConsumer, som udfører den specificerede handling for alle medarbejdere.

BiPredicate<T, U>

BiPredicate er et funktionelt interface, der tager to argumenter af typerne T og U og returnerer et boolesk resultat.

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

Det bruges til at kontrollere betingelser, hvor resultatet er en boolesk værdi (true eller false), baseret på analyse af to inputværdier.

For eksempel kan man kontrollere, om længden af en streng er større end et givet tal:

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. Hvilken metode er den primære i interfacet `BiFunction<T, U, R>`?

2. Hvad returnerer metoden `accept(T t, U u)` i interfacet `BiConsumer<T, U>`?

3. Hvilket interface bruges til at kontrollere en logisk betingelse med to argumenter?

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 13

Bi-versioner af Funktionelle Grænseflader

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Hvilken metode er den primære i interfacet BiFunction<T, U, R>?

2. Hvad returnerer metoden accept(T t, U u) i interfacet BiConsumer<T, U>?

3. Hvilket interface bruges til at kontrollere en logisk betingelse med to argumenter?

Awesome!

Bi-versioner af Funktionelle Grænseflader

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Hvilken metode er den primære i interfacet BiFunction<T, U, R>?

2. Hvad returnerer metoden accept(T t, U u) i interfacet BiConsumer<T, U>?

3. Hvilket interface bruges til at kontrollere en logisk betingelse med to argumenter?

1. Hvilken metode er den primære i interfacet `BiFunction<T, U, R>`?

2. Hvad returnerer metoden `accept(T t, U u)` i interfacet `BiConsumer<T, U>`?

1. Hvilken metode er den primære i interfacet `BiFunction<T, U, R>`?

2. Hvad returnerer metoden `accept(T t, U u)` i interfacet `BiConsumer<T, U>`?