Aprenda Bi-Versões de Interfaces Funcionais | Fundamentos e Capacidades Funcionais da Stream API

Em Java, existem várias versões bi de interfaces funcionais que trabalham com dois argumentos. Essas interfaces fornecem modelos convenientes para realizar diversas operações com um par de dados de entrada, seja para calcular um resultado, executar uma ação ou verificar uma condição.

Elas simplificam o tratamento de cenários complexos nos quais é necessário trabalhar com dois parâmetros simultaneamente.

Por exemplo, em vez de escrever um código extenso com várias chamadas aninhadas, é possível aproveitar interfaces concisas que oferecem métodos prontos para implementar funcionalidades essenciais.

BiFunction<T, U, R>

BiFunction é uma interface funcional que recebe dois argumentos de entrada dos tipos T e U, e retorna um resultado do tipo R.

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

BiFunction é ideal para situações em que dois valores precisam ser processados e um resultado derivado deve ser retornado, como em cálculos, transformações ou combinação de dados.

Por exemplo, caso seja necessário calcular o custo total de itens em estoque multiplicando a quantidade pelo preço por unidade:

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

Neste exemplo, BiFunction<Integer, Double, Double> aceita dois argumentos: quantity e pricePerUnit (preço por unidade), e retorna o resultado — o custo total como um valor Double. O método apply() executa a operação especificada, vinculando a interface funcional à lógica de multiplicação.

BiConsumer<T, U>

BiConsumer é uma interface funcional que recebe dois argumentos dos tipos T e U, mas não retorna um resultado.

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

Utilizado para realizar ações em dois objetos, como registro de logs, exibição de informações ou armazenamento de dados.

Por exemplo, considere a criação de uma interface funcional que recebe o nome do funcionário e o salário, formata os dados e imprime no 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);
    }
}

Neste exemplo, BiConsumer<String, Double> é utilizado para processar o nome do funcionário e o salário, imprimindo os dados no console de forma formatada.

O método forEach() da coleção Map repassa cada par chave-valor para o BiConsumer, que executa a ação especificada para todos os funcionários.

BiPredicate<T, U>

BiPredicate é uma interface funcional que recebe dois argumentos dos tipos T e U e retorna um resultado booleano.

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

É utilizada para verificação de condições onde o resultado é um valor booleano (true ou false), com base na análise de dois valores de entrada.

Por exemplo, verificar se o comprimento de uma string é maior que um determinado número:

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

Neste exemplo, BiPredicate<String, Integer> aceita dois argumentos: a string str e o número length, representando o comprimento mínimo. O método test() verifica a condição, retornando true se o comprimento da string for maior que o número especificado, ou false caso contrário.

1. Qual método é o principal na interface `BiFunction<T, U, R>`?

2. O que o método `accept(T t, U u)` da interface `BiConsumer<T, U>` retorna?

3. Qual interface é usada para verificar uma condição lógica com dois argumentos?

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 13

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

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

Deslize para mostrar o menu

Elas simplificam o tratamento de cenários complexos nos quais é necessário trabalhar com dois parâmetros simultaneamente.

BiFunction<T, U, R>

BiFunction é uma interface funcional que recebe dois argumentos de entrada dos tipos T e U, e retorna um resultado do tipo R.

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

Por exemplo, caso seja necessário calcular o custo total de itens em estoque multiplicando a quantidade pelo preço por unidade:

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 é uma interface funcional que recebe dois argumentos dos tipos T e U, mas não retorna um resultado.

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

Utilizado para realizar ações em dois objetos, como registro de logs, exibição de informações ou armazenamento de dados.

Por exemplo, considere a criação de uma interface funcional que recebe o nome do funcionário e o salário, formata os dados e imprime no 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);
    }
}

Neste exemplo, BiConsumer<String, Double> é utilizado para processar o nome do funcionário e o salário, imprimindo os dados no console de forma formatada.

O método forEach() da coleção Map repassa cada par chave-valor para o BiConsumer, que executa a ação especificada para todos os funcionários.

BiPredicate<T, U>

BiPredicate é uma interface funcional que recebe dois argumentos dos tipos T e U e retorna um resultado booleano.

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

É utilizada para verificação de condições onde o resultado é um valor booleano (true ou false), com base na análise de dois valores de entrada.

Por exemplo, verificar se o comprimento de uma string é maior que um determinado número:

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 método é o principal na interface `BiFunction<T, U, R>`?

2. O que o método `accept(T t, U u)` da interface `BiConsumer<T, U>` retorna?

3. Qual interface é usada para verificar uma condição lógica com dois argumentos?

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 1. Capítulo 13

Bi-Versões de Interfaces Funcionais

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Qual método é o principal na interface BiFunction<T, U, R>?

2. O que o método accept(T t, U u) da interface BiConsumer<T, U> retorna?

3. Qual interface é usada para verificar uma condição lógica com dois argumentos?

Awesome!

Bi-Versões de Interfaces Funcionais

BiFunction<T, U, R>

BiConsumer<T, U>

BiPredicate<T, U>

1. Qual método é o principal na interface BiFunction<T, U, R>?

2. O que o método accept(T t, U u) da interface BiConsumer<T, U> retorna?

3. Qual interface é usada para verificar uma condição lógica com dois argumentos?

1. Qual método é o principal na interface `BiFunction<T, U, R>`?

2. O que o método `accept(T t, U u)` da interface `BiConsumer<T, U>` retorna?

1. Qual método é o principal na interface `BiFunction<T, U, R>`?

2. O que o método `accept(T t, U u)` da interface `BiConsumer<T, U>` retorna?