Lära Bi-versioner av funktionella gränssnitt | Grunder och Funktionella Möjligheter med Stream API

I Java finns det flera bi-versioner av funktionella gränssnitt som arbetar med två argument. Dessa gränssnitt erbjuder praktiska mallar för att utföra olika operationer med ett par av indata, oavsett om det gäller att beräkna ett resultat, utföra en åtgärd eller kontrollera ett villkor.

De förenklar hanteringen av komplexa scenarier där det krävs att arbeta med två parametrar samtidigt.

Istället för att skriva omfattande kod med flera nästlade anrop kan du dra nytta av koncisa gränssnitt som erbjuder färdiga metoder för att implementera centrala funktionaliteter.

BiFunction<T, U, R>

BiFunction är ett funktionellt gränssnitt som tar emot två indataargument av typerna T och U, och returnerar ett resultat av typen R.

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

BiFunction är optimal för uppgifter där två värden behöver bearbetas och ett härlett resultat returneras, såsom beräkning, omvandling eller datakombination.

Till exempel, om det behövs att beräkna den totala kostnaden för varor i lager genom att multiplicera kvantiteten med priset 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 detta exempel accepterar BiFunction<Integer, Double, Double> två argument: quantity och pricePerUnit (pris per enhet), och returnerar resultatet — totalkostnaden som ett Double-värde. Metoden apply() utför den angivna operationen och kopplar samman funktionellt gränssnitt med multiplikationslogik.

BiConsumer<T, U>

BiConsumer är ett funktionellt gränssnitt som tar emot två argument av typerna T och U, men returnerar inget resultat.

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

Används för att utföra åtgärder på två objekt, såsom loggning, visning av information eller lagring av data.

Till exempel, skapa ett funktionellt gränssnitt som tar emot en anställds namn och lön, formaterar uppgifterna och skriver ut dem till konsolen:

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 detta exempel används BiConsumer<String, Double> för att bearbeta anställdens namn och lön, och skriver ut uppgifterna till konsolen på ett formaterat sätt.

Metoden forEach() i Map-samlingen skickar varje nyckel-värde-par till BiConsumer, som utför den angivna åtgärden för alla anställda.

BiPredicate<T, U>

BiPredicate är ett funktionellt gränssnitt som tar två argument av typerna T och U och returnerar ett boolean-resultat.

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

Det används för villkorskontroller där resultatet är ett boolean-värde (true eller false), baserat på analys av två inmatningsvärden.

Till exempel, kontrollera om längden på en sträng är större än ett 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 det här exemplet tar BiPredicate<String, Integer> emot två argument: strängen str och talet length, som representerar minimilängden. Metoden test() kontrollerar villkoret och returnerar true om strängens längd är större än det angivna talet, annars false.

1. Vilken metod är den huvudsakliga i gränssnittet `BiFunction<T, U, R>`?

2. Vad returnerar metoden `accept(T t, U u)` i gränssnittet `BiConsumer<T, U>`?

3. Vilket gränssnitt används för att kontrollera ett logiskt villkor med två argument?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 13

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Awesome!

Completion rate improved to 2.33

Svep för att visa menyn

De förenklar hanteringen av komplexa scenarier där det krävs att arbeta med två parametrar samtidigt.

BiFunction<T, U, R>

BiFunction är ett funktionellt gränssnitt som tar emot två indataargument av typerna T och U, och returnerar ett resultat av typen R.

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

BiFunction är optimal för uppgifter där två värden behöver bearbetas och ett härlett resultat returneras, såsom beräkning, omvandling eller datakombination.

Till exempel, om det behövs att beräkna den totala kostnaden för varor i lager genom att multiplicera kvantiteten med priset 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 är ett funktionellt gränssnitt som tar emot två argument av typerna T och U, men returnerar inget resultat.

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

Används för att utföra åtgärder på två objekt, såsom loggning, visning av information eller lagring av data.

Till exempel, skapa ett funktionellt gränssnitt som tar emot en anställds namn och lön, formaterar uppgifterna och skriver ut dem till konsolen:

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 detta exempel används BiConsumer<String, Double> för att bearbeta anställdens namn och lön, och skriver ut uppgifterna till konsolen på ett formaterat sätt.

Metoden forEach() i Map-samlingen skickar varje nyckel-värde-par till BiConsumer, som utför den angivna åtgärden för alla anställda.

BiPredicate<T, U>

BiPredicate är ett funktionellt gränssnitt som tar två argument av typerna T och U och returnerar ett boolean-resultat.

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

Det används för villkorskontroller där resultatet är ett boolean-värde (true eller false), baserat på analys av två inmatningsvärden.

Till exempel, kontrollera om längden på en sträng är större än ett 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. Vilken metod är den huvudsakliga i gränssnittet `BiFunction<T, U, R>`?

2. Vad returnerar metoden `accept(T t, U u)` i gränssnittet `BiConsumer<T, U>`?

3. Vilket gränssnitt används för att kontrollera ett logiskt villkor med två argument?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 13

Bi-versioner av funktionella gränssnitt

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Vilken metod är den huvudsakliga i gränssnittet BiFunction<T, U, R>?

2. Vad returnerar metoden accept(T t, U u) i gränssnittet BiConsumer<T, U>?

3. Vilket gränssnitt används för att kontrollera ett logiskt villkor med två argument?

Awesome!

Bi-versioner av funktionella gränssnitt

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Vilken metod är den huvudsakliga i gränssnittet BiFunction<T, U, R>?

2. Vad returnerar metoden accept(T t, U u) i gränssnittet BiConsumer<T, U>?

3. Vilket gränssnitt används för att kontrollera ett logiskt villkor med två argument?

1. Vilken metod är den huvudsakliga i gränssnittet `BiFunction<T, U, R>`?

2. Vad returnerar metoden `accept(T t, U u)` i gränssnittet `BiConsumer<T, U>`?

1. Vilken metod är den huvudsakliga i gränssnittet `BiFunction<T, U, R>`?

2. Vad returnerar metoden `accept(T t, U u)` i gränssnittet `BiConsumer<T, U>`?