Lære Bi-versjoner av funksjonelle grensesnitt | Grunnleggende og Funksjonelle Egenskaper ved Stream API

I Java finnes det flere bi-versjoner av funksjonelle grensesnitt som arbeider med to argumenter. Disse grensesnittene gir praktiske maler for å utføre ulike operasjoner med et par av inndata, enten det gjelder beregning av et resultat, utførelse av en handling eller sjekk av en betingelse.

De forenkler håndteringen av komplekse scenarier der det er nødvendig å arbeide med to parametere samtidig.

For eksempel, i stedet for å skrive omfattende kode med flere nestede kall, kan du dra nytte av konsise grensesnitt som tilbyr ferdige metoder for å implementere nøkkelfunksjonalitet.

BiFunction<T, U, R>

BiFunction er et funksjonelt grensesnitt som tar to inndataargumenter av typene T og U, og returnerer et resultat av typen R.

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

BiFunction er ideell for oppgaver der to verdier må behandles og et avledet resultat returneres, slik som beregning, transformasjon eller datakombinasjon.

For eksempel, hvis det er nødvendig å beregne totalkostnaden for varer på lager ved å multiplisere antall med pris per enhet:

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 eksemplet aksepterer BiFunction<Integer, Double, Double> to argumenter: quantity og pricePerUnit (pris per enhet), og returnerer resultatet — totalkostnaden som en Double-verdi. Metoden apply() utfører den spesifiserte operasjonen, og kobler funksjonelt grensesnitt med multiplikasjonslogikken.

BiConsumer<T, U>

BiConsumer er et funksjonelt grensesnitt som tar to argumenter av typene T og U, men returnerer ikke et resultat.

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

Brukes for å utføre handlinger på to objekter, som for eksempel logging, visning av informasjon eller lagring av data.

For eksempel kan vi lage et funksjonelt grensesnitt som tar imot ansattens navn og lønn, formaterer dataene og skriver dem ut 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 eksemplet brukes BiConsumer<String, Double> til å behandle ansattens navn og lønn, og skriver dataene til konsollen på en formatert måte.

Metoden forEach() i Map-samlingen sender hvert nøkkel-verdi-par til BiConsumer, som utfører den spesifiserte handlingen for alle ansatte.

BiPredicate<T, U>

BiPredicate er et funksjonelt grensesnitt som tar to argumenter av typene T og U og returnerer et boolsk resultat.

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

Den brukes for å sjekke betingelser der resultatet er en boolsk verdi (true eller false), basert på analyse av to inndata.

For eksempel, la oss sjekke om lengden på en streng er større enn et gitt tall:

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 eksemplet tar BiPredicate<String, Integer> imot to argumenter: strengen str og tallet length, som representerer minimumslengden. Metoden test() sjekker betingelsen, og returnerer true hvis strengens lengde er større enn det spesifiserte tallet, ellers false.

1. Hvilken metode er hovedmetoden i `BiFunction<T, U, R>`-grensesnittet?

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

3. Hvilket grensesnitt brukes for å sjekke en logisk betingelse med to argumenter?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 13

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

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

Sveip for å vise menyen

De forenkler håndteringen av komplekse scenarier der det er nødvendig å arbeide med to parametere samtidig.

BiFunction<T, U, R>

BiFunction er et funksjonelt grensesnitt som tar to inndataargumenter av typene T og U, og returnerer et resultat av typen R.

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

BiFunction er ideell for oppgaver der to verdier må behandles og et avledet resultat returneres, slik som beregning, transformasjon eller datakombinasjon.

For eksempel, hvis det er nødvendig å beregne totalkostnaden for varer på lager ved å multiplisere antall med pris per enhet:

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 funksjonelt grensesnitt som tar to argumenter av typene T og U, men returnerer ikke et resultat.

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

Brukes for å utføre handlinger på to objekter, som for eksempel logging, visning av informasjon eller lagring av data.

For eksempel kan vi lage et funksjonelt grensesnitt som tar imot ansattens navn og lønn, formaterer dataene og skriver dem ut 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 eksemplet brukes BiConsumer<String, Double> til å behandle ansattens navn og lønn, og skriver dataene til konsollen på en formatert måte.

Metoden forEach() i Map-samlingen sender hvert nøkkel-verdi-par til BiConsumer, som utfører den spesifiserte handlingen for alle ansatte.

BiPredicate<T, U>

BiPredicate er et funksjonelt grensesnitt som tar to argumenter av typene T og U og returnerer et boolsk resultat.

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

Den brukes for å sjekke betingelser der resultatet er en boolsk verdi (true eller false), basert på analyse av to inndata.

For eksempel, la oss sjekke om lengden på en streng er større enn et gitt tall:

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 hovedmetoden i `BiFunction<T, U, R>`-grensesnittet?

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

3. Hvilket grensesnitt brukes for å sjekke en logisk betingelse med to argumenter?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 13

Bi-versjoner av funksjonelle grensesnitt

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Hvilken metode er hovedmetoden i BiFunction<T, U, R>-grensesnittet?

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

3. Hvilket grensesnitt brukes for å sjekke en logisk betingelse med to argumenter?

Awesome!

Bi-versjoner av funksjonelle grensesnitt

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Hvilken metode er hovedmetoden i BiFunction<T, U, R>-grensesnittet?

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

3. Hvilket grensesnitt brukes for å sjekke en logisk betingelse med to argumenter?

1. Hvilken metode er hovedmetoden i `BiFunction<T, U, R>`-grensesnittet?

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

1. Hvilken metode er hovedmetoden i `BiFunction<T, U, R>`-grensesnittet?

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