Aprende Bi-Versiones de Interfaces Funcionales | Fundamentos y Capacidades Funcionales de Stream API

En Java, existen varias versiones "bi" de interfaces funcionales que trabajan con dos argumentos. Estas interfaces proporcionan plantillas convenientes para realizar diversas operaciones con un par de datos de entrada, ya sea calcular un resultado, realizar una acción o verificar una condición.

Estas simplifican el manejo de escenarios complejos donde es necesario trabajar con dos parámetros al mismo tiempo.

Por ejemplo, en lugar de escribir código voluminoso con múltiples llamadas anidadas, se pueden aprovechar interfaces concisas que ofrecen métodos listos para implementar funcionalidades clave.

BiFunction<T, U, R>

BiFunction es una interfaz funcional que recibe dos argumentos de entrada de tipos T y U, y devuelve un resultado de tipo R.

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

BiFunction es ideal para tareas donde se deben procesar dos valores y se retorna un resultado derivado, como cálculo, transformación o combinación de datos.

Por ejemplo, si se requiere calcular el costo total de los artículos en inventario multiplicando la cantidad por el precio por unidad:

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

En este ejemplo, BiFunction<Integer, Double, Double> acepta dos argumentos: quantity y pricePerUnit (precio por unidad), y devuelve el resultado — el costo total como un valor de tipo Double. El método apply() realiza la operación especificada, vinculando la interfaz funcional con la lógica de multiplicación.

BiConsumer<T, U>

BiConsumer es una interfaz funcional que recibe dos argumentos de tipos T y U, pero no devuelve un resultado.

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

Se utiliza para realizar acciones sobre dos objetos, como registrar eventos, mostrar información o guardar datos.

Por ejemplo, se puede crear una interfaz funcional que acepte el nombre del empleado y el salario, formatee los datos y los imprima en la consola:

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

En este ejemplo, BiConsumer<String, Double> se utiliza para procesar el nombre del empleado y el salario, imprimiendo los datos en la consola de manera formateada.

El método forEach() de la colección Map pasa cada par clave-valor al BiConsumer, que realiza la acción especificada para todos los empleados.

BiPredicate<T, U>

BiPredicate es una interfaz funcional que recibe dos argumentos de tipos T y U y devuelve un resultado booleano.

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

Se utiliza para verificar condiciones donde el resultado es un valor booleano (true o false), basado en el análisis de dos valores de entrada.

Por ejemplo, comprobar si la longitud de una cadena es mayor que un número dado:

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

En este ejemplo, BiPredicate<String, Integer> acepta dos argumentos: la cadena str y el número length, que representa la longitud mínima. El método test() verifica la condición, devolviendo true si la longitud de la cadena es mayor que el número especificado, o false en caso contrario.

1. ¿Cuál es el método principal en la interfaz `BiFunction<T, U, R>`?

2. ¿Qué devuelve el método `accept(T t, U u)` de la interfaz `BiConsumer<T, U>`?

3. ¿Qué interfaz se utiliza para comprobar una condición lógica con dos argumentos?

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 1. Capítulo 13

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

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?

Desliza para mostrar el menú

Estas simplifican el manejo de escenarios complejos donde es necesario trabajar con dos parámetros al mismo tiempo.

BiFunction<T, U, R>

BiFunction es una interfaz funcional que recibe dos argumentos de entrada de tipos T y U, y devuelve un resultado de tipo R.

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

BiFunction es ideal para tareas donde se deben procesar dos valores y se retorna un resultado derivado, como cálculo, transformación o combinación de datos.

Por ejemplo, si se requiere calcular el costo total de los artículos en inventario multiplicando la cantidad por el precio por unidad:

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 es una interfaz funcional que recibe dos argumentos de tipos T y U, pero no devuelve un resultado.

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

Se utiliza para realizar acciones sobre dos objetos, como registrar eventos, mostrar información o guardar datos.

Por ejemplo, se puede crear una interfaz funcional que acepte el nombre del empleado y el salario, formatee los datos y los imprima en la consola:

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

En este ejemplo, BiConsumer<String, Double> se utiliza para procesar el nombre del empleado y el salario, imprimiendo los datos en la consola de manera formateada.

El método forEach() de la colección Map pasa cada par clave-valor al BiConsumer, que realiza la acción especificada para todos los empleados.

BiPredicate<T, U>

BiPredicate es una interfaz funcional que recibe dos argumentos de tipos T y U y devuelve un resultado booleano.

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

Se utiliza para verificar condiciones donde el resultado es un valor booleano (true o false), basado en el análisis de dos valores de entrada.

Por ejemplo, comprobar si la longitud de una cadena es mayor que un número dado:

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. ¿Cuál es el método principal en la interfaz `BiFunction<T, U, R>`?

2. ¿Qué devuelve el método `accept(T t, U u)` de la interfaz `BiConsumer<T, U>`?

3. ¿Qué interfaz se utiliza para comprobar una condición lógica con dos argumentos?

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 1. Capítulo 13

Bi-Versiones de Interfaces Funcionales

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. ¿Cuál es el método principal en la interfaz BiFunction<T, U, R>?

2. ¿Qué devuelve el método accept(T t, U u) de la interfaz BiConsumer<T, U>?

3. ¿Qué interfaz se utiliza para comprobar una condición lógica con dos argumentos?

Bi-Versiones de Interfaces Funcionales

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. ¿Cuál es el método principal en la interfaz BiFunction<T, U, R>?

2. ¿Qué devuelve el método accept(T t, U u) de la interfaz BiConsumer<T, U>?

3. ¿Qué interfaz se utiliza para comprobar una condición lógica con dos argumentos?

1. ¿Cuál es el método principal en la interfaz `BiFunction<T, U, R>`?

2. ¿Qué devuelve el método `accept(T t, U u)` de la interfaz `BiConsumer<T, U>`?

1. ¿Cuál es el método principal en la interfaz `BiFunction<T, U, R>`?

2. ¿Qué devuelve el método `accept(T t, U u)` de la interfaz `BiConsumer<T, U>`?