Impara Biversioni delle Interfacce Funzionali | Fondamenti e Capacità Funzionali dello Stream API

In Java, esistono diverse interfacce funzionali bi-versione che lavorano con due argomenti. Queste interfacce forniscono modelli pratici per eseguire varie operazioni con una coppia di dati di input, sia che si tratti di calcolare un risultato, eseguire un'azione o verificare una condizione.

Esse semplificano la gestione di scenari complessi in cui è necessario lavorare con due parametri contemporaneamente.

Ad esempio, invece di scrivere codice ingombrante con molte chiamate annidate, è possibile sfruttare interfacce concise che offrono metodi già pronti per implementare funzionalità chiave.

BiFunction<T, U, R>

BiFunction è un'interfaccia funzionale che accetta due argomenti di input di tipo T e U, e restituisce un risultato di tipo R.

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

BiFunction è ideale per attività in cui è necessario elaborare due valori e restituire un risultato derivato, come calcolo, trasformazione o combinazione di dati.

Ad esempio, se occorre calcolare il costo totale degli articoli in magazzino moltiplicando la quantità per il prezzo unitario:

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 questo esempio, BiFunction<Integer, Double, Double> accetta due argomenti: quantity e pricePerUnit (prezzo per unità), e restituisce il risultato — il costo totale come valore Double. Il metodo apply() esegue l'operazione specificata, collegando l'interfaccia funzionale con la logica di moltiplicazione.

BiConsumer<T, U>

BiConsumer è un'interfaccia funzionale che accetta due argomenti di tipo T e U, ma non restituisce alcun risultato.

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

Viene utilizzato per eseguire azioni su due oggetti, come registrazione, visualizzazione di informazioni o salvataggio di dati.

Ad esempio, creiamo un'interfaccia funzionale che accetta il nome di un dipendente e il salario, formatta i dati e li stampa sulla console:

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 questo esempio, BiConsumer<String, Double> viene utilizzato per elaborare il nome e il salario del dipendente, stampando i dati sulla console in modo formattato.

Il metodo forEach() della collezione Map passa ogni coppia chiave-valore al BiConsumer, che esegue l'azione specificata per tutti i dipendenti.

BiPredicate<T, U>

BiPredicate è un interfaccia funzionale che accetta due argomenti di tipo T e U e restituisce un risultato booleano.

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

Viene utilizzata per verificare condizioni in cui il risultato è un valore booleano (true o false), basato sull'analisi di due valori di input.

Ad esempio, si può verificare se la lunghezza di una stringa è maggiore di un numero dato:

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 questo esempio, BiPredicate<String, Integer> accetta due argomenti: la stringa str e il numero length, che rappresenta la lunghezza minima. Il metodo test() verifica la condizione, restituendo true se la lunghezza della stringa è maggiore del numero specificato, oppure false in caso contrario.

1. Qual è il metodo principale nell'interfaccia `BiFunction<T, U, R>`?

2. Cosa restituisce il metodo `accept(T t, U u)` dell'interfaccia `BiConsumer<T, U>`?

3. Quale interfaccia viene utilizzata per verificare una condizione logica con due argomenti?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 13

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Awesome!

Completion rate improved to 2.33

Scorri per mostrare il menu

Esse semplificano la gestione di scenari complessi in cui è necessario lavorare con due parametri contemporaneamente.

BiFunction<T, U, R>

BiFunction è un'interfaccia funzionale che accetta due argomenti di input di tipo T e U, e restituisce un risultato di tipo R.

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

BiFunction è ideale per attività in cui è necessario elaborare due valori e restituire un risultato derivato, come calcolo, trasformazione o combinazione di dati.

Ad esempio, se occorre calcolare il costo totale degli articoli in magazzino moltiplicando la quantità per il prezzo unitario:

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 è un'interfaccia funzionale che accetta due argomenti di tipo T e U, ma non restituisce alcun risultato.

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

Viene utilizzato per eseguire azioni su due oggetti, come registrazione, visualizzazione di informazioni o salvataggio di dati.

Ad esempio, creiamo un'interfaccia funzionale che accetta il nome di un dipendente e il salario, formatta i dati e li stampa sulla console:

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 questo esempio, BiConsumer<String, Double> viene utilizzato per elaborare il nome e il salario del dipendente, stampando i dati sulla console in modo formattato.

Il metodo forEach() della collezione Map passa ogni coppia chiave-valore al BiConsumer, che esegue l'azione specificata per tutti i dipendenti.

BiPredicate<T, U>

BiPredicate è un interfaccia funzionale che accetta due argomenti di tipo T e U e restituisce un risultato booleano.

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

Viene utilizzata per verificare condizioni in cui il risultato è un valore booleano (true o false), basato sull'analisi di due valori di input.

Ad esempio, si può verificare se la lunghezza di una stringa è maggiore di un numero dato:

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. Qual è il metodo principale nell'interfaccia `BiFunction<T, U, R>`?

2. Cosa restituisce il metodo `accept(T t, U u)` dell'interfaccia `BiConsumer<T, U>`?

3. Quale interfaccia viene utilizzata per verificare una condizione logica con due argomenti?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 13

Biversioni delle Interfacce Funzionali

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Qual è il metodo principale nell'interfaccia BiFunction<T, U, R>?

2. Cosa restituisce il metodo accept(T t, U u) dell'interfaccia BiConsumer<T, U>?

3. Quale interfaccia viene utilizzata per verificare una condizione logica con due argomenti?

Awesome!

Biversioni delle Interfacce Funzionali

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Qual è il metodo principale nell'interfaccia BiFunction<T, U, R>?

2. Cosa restituisce il metodo accept(T t, U u) dell'interfaccia BiConsumer<T, U>?

3. Quale interfaccia viene utilizzata per verificare una condizione logica con due argomenti?

1. Qual è il metodo principale nell'interfaccia `BiFunction<T, U, R>`?

2. Cosa restituisce il metodo `accept(T t, U u)` dell'interfaccia `BiConsumer<T, U>`?

1. Qual è il metodo principale nell'interfaccia `BiFunction<T, U, R>`?

2. Cosa restituisce il metodo `accept(T t, U u)` dell'interfaccia `BiConsumer<T, U>`?