Java-委托

概述

Supplier、Function、Predicate、Consumer、BiFunction、BiPredicate、BiConsumer是Java函数式接口的一部分，它们用于定义不同类型的函数，从而在函数式编程中提供了更灵活的方式来处理数据。

这些函数式接口可以通过Lambda表达式来实现，从而简化代码的编写。在函数式编程中，它们可以作为方法的参数或返回值，用于描述不同的行为和操作，提高代码的可读性和可维护性。

详细
Supplier<T>

抽象方法：T get()
用途：表示一个供应商，不接受任何参数，返回一个结果。
使用场景：当需要获取一个对象，而该对象的创建逻辑比较复杂或者需要重复使用时，可以使用Supplier。

public class ProductManager 
{
    public static void main(String[] args) 
    {
        Product product = createProduct(() -> 
        {
        // 从数据库获取商品信息并创建Product对象
        return getFromDatabase();
        });

        System.out.println(product);
    }

    public static Product createProduct(Supplier<Product> supplier)
    {
        return supplier.get();
    }

    public static Product getFromDatabase() 
    {
        // 从数据库获取商品信息
        // ...
        return new Product("iPhone", 999);
    }
}
class Product 
{
    private String name;
    private double price;

    public Product(String name, double price) 
    {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() 
    {
        return "Product{" +
        "name='" + name + '\'' +
        ", price=" + price +
        '}';
    }
}

Function<T, R>

抽象方法：R apply(T t)
用途：表示一个接受一个输入参数并返回一个结果的函数。
使用场景：当需要对输入参数进行处理，并返回一个结果时，可以使用Function。

public class SalaryCalculator 
{
    public static void main(String[] args) 
    {
        Employee employee = new Employee("John", 40, 25.0);
        double salary = calculateSalary(employee, emp -> emp.getHoursWorked() * emp.getHourlyRate());
        System.out.println("Salary: " + salary);
    }

    public static double calculateSalary(Employee employee, Function<Employee, Double> salaryFunction) 
    {
        return salaryFunction.apply(employee);
    }
}

class Employee {
    private String name;
    private int hoursWorked;
    private double hourlyRate;

    public Employee(String name, int hoursWorked, double hourlyRate) {
        this.name = name;
        this.hoursWorked = hoursWorked;
        this.hourlyRate = hourlyRate;
    }

    public String getName() {
        return name;
    }

    public int getHoursWorked() {
        return hoursWorked;
    }

    public double getHourlyRate() {
        return hourlyRate;
    }
}

Predicate<T>

抽象方法：boolean test(T t)
用途：表示一个断言，接受一个输入参数并返回一个布尔值。
使用场景：当需要对输入参数进行条件判断时，可以使用Predicate。

public class FilterFruits {
    public static void main(String[] args) {
        List<Fruit> fruits = new ArrayList<>();
        fruits.add(new Fruit("Apple", "Red", 100));
        fruits.add(new Fruit("Banana", "Yellow", 150));
        fruits.add(new Fruit("Orange", "Orange", 120));
 
        List<Fruit> redFruits = filterFruits(fruits, fruit -> fruit.getColor().equals("Red"));
        System.out.println("Red fruits: " + redFruits);
    }
 
    public static List<Fruit> filterFruits(List<Fruit> fruits, Predicate<Fruit> predicate) {
        List<Fruit> filteredFruits = new ArrayList<>();
        for (Fruit fruit : fruits) {
            if (predicate.test(fruit)) {
                filteredFruits.add(fruit);
            }
        }
        return filteredFruits;
    }
}
 
class Fruit {
    private String name;
    private String color;
    private int weight;
 
    public Fruit(String name, String color, int weight) {
        this.name = name;
        this.color = color;
        this.weight = weight;
    }
 
    public String getName() {
        return name;
    }
 
    public String getColor() {
        return color;
    }
 
    public int getWeight() {
        return weight;
    }
 
    @Override
    public String toString() {
        return "Fruit{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", weight=" + weight +
                '}';
    }
}

Consumer<T>

• 抽象方法：void accept(T t)
• 用途：表示一个接受一个输入参数并没有返回值的操作。
• 使用场景：当需要对输入参数进行一些操作，而不需要返回结果时，可以使用Consumer

public class ProcessNumbers {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
 
        processNumbers(numbers, number -> System.out.println("Processing number: " + number));
    }
 
    public static void processNumbers(List<Integer> numbers, Consumer<Integer> consumer) {
        for (Integer number : numbers) {
            consumer.accept(number);
        }
    }
}

BiFunction<T, U, R>、BiPredicate<T, U>、BiConsumer<T, U>

和Function、Predicate、Consumer一样，只是一个入参变成了两个

Mybatis框架里就有很多地方用到了Bi的，如：ResultHandler、ResultSetHandler、ParameterHandler、StatementHandle

本文内容出自（原文）链接：https://blog.csdn.net/zxcyxg123/article/details/131802672