Java-委託

李文学發表於2024-03-20
原文網址 : https://www.cnblogs.com/oumi/p/18084417
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

相關文章