Java 中的預設函數式介面

剛學習完 Java 中的預設函數接口，我想把它們全部分享出來！
函數式介面是只有一種抽象方法的介面。如果您要處理 lambda 表達式（函數式程式設計），它們是必需的。它們簡化了代碼並廣泛用於流中。雖然您可以建立自己的函數式接口，但當 Java 為我們提供了一些重要的介面（例如 Consumer、Predicate、Function 和Supplier）時，為什麼還要擔心呢？

1. 消費者：

Consumer 是一個函數式接口，表示接受單一輸入參數且不傳回結果的操作。它通常用於對給定參數執行操作（例如列印或記錄）而不修改它。

簽名：void Accept(T t)（其中 T 是一般型別）

2. 謂詞：

Predicate 是一個函數式接口，表示傳回布林值的單一參數函數。它通常用於過濾或評估條件（例如，檢查數字是否為偶數）。

簽名：布林測試(T t)

3、功能：

Function 是一種函數式接口，表示接受一個參數並產生結果的函數。它通常用於轉換（例如，將一種類型轉換為另一種類型或修改資料）。

簽名：R apply(T t)

4. 供應商：

Supplier 是一個函數式接口，它表示一個沒有輸入參數並傳回結果的函數。它通常用於產生或提供值而不需要輸入。

簽名：T get()

我們可以透過定義接受這些介面作為參數的通用方法來有效地使用函數式接口，例如 Consumer、Predicate、Function 和Supplier。這使我們能夠利用泛型的強大功能並確保我們的方法可以適用於各種類型。

這是完整程式碼的範例，示範了所有功能

import java.util.List;
import java.util.Random;
import java.util.function.*;

public class Main {
    public static void main(String[] args) {
        // Consumer
        usingConsumer((a) -> System.out.printf("Hello %s", a), "saami");
        System.out.println();
        // Bi-Consumer
        usingBiConsumer((a, b) -> System.out.printf("Name: %s, Age: %d", a, b), "saami", 20);
        System.out.println();
        // Predicate
        var result1 = usingPredicate((a) -> a % 2 == 0, 34);

        if (result1) {
            System.out.println("Even");
        } else {
            System.out.println("Odd");
        }
        // Bi-Predicate
        var result2 = usingBiPredicate((a, b) -> a > b, 12, 22);
        if (result2) {
            System.out.println("Greater");
        } else {
            System.out.println("Lesser");
        }
        // Function
        var result3 = usingFunction((a) -> a + ": this is a number", 5);
        System.out.println(result3);

        // Bi-Function
        var result4 = usingBiFunction((a, b) -> (a > b ? "Greater": "Lesser"), 5, 6);
        System.out.println(result4);

        // Unary-Operator
        var result5 = usingUnaryOperator((a) -> a+5, 10);
        System.out.println(result5);

        // Binary-Operator
        var result6 = usingBinaryOperator((a, b) -> a + b, 12, 32);
        System.out.println(result6);
        Random r = new Random();


        // Function as Predicate
        var result7 = usingFunctionAsPredicate((a) -> a > 99, 999);
        System.out.println(result7);

        // Using Consumer for printing of the list.
        printData((a) -> {
            for (var ele : a) {
                System.out.println(ele);
            }
        } , List.of("S1", "S2", "S3", "S4", "S5"));

        // Using Supplier as a random number generator
        String[] arr = {"saami", "john", "raymond", "puff"};
        System.out.println(getRandomOne(arr, () -> new Random().nextInt(arr.length)));

        // Using Custom Comparator
        System.out.println(usingCustomFunctionalInterface((a, b, c) -> a + b + c, "Saami", " Abbas", " Khan"));

    }

    public static <T> void usingConsumer(Consumer<T> consumer, T a) {
        // Method that takes consumer interface will return void.
        // Can print something constituting 'a'
        consumer.accept(a);
    }

    public static <T, L> void usingBiConsumer(BiConsumer<T, L> biConsumer, T a, L b) {
        biConsumer.accept(a, b);
    }

    public static <T> boolean usingPredicate(Predicate<T> predicate, T a) {
        return predicate.test(a);
    }

    public static <T, L> boolean usingBiPredicate(BiPredicate<T, L> biPredicate, T a, L b) {
        return biPredicate.test(a, b);
    }

    public static <T, R> R usingFunction(Function<T, R> function, T a) {
//        T for the parameter and R for the return type here the return type could be as same as T or
//        could be different like if T is Integer the R could be String 8 + ""
        return function.apply(a);
    }

    public static <T, U, R> R usingBiFunction(BiFunction<T, U, R> biFunction, T a, U b) {
        return biFunction.apply(a, b);
    }

    public static <T> T usingUnaryOperator(UnaryOperator<T> unaryOperator, T a) {
        return unaryOperator.apply(a);
    }

    public static <T> T usingBinaryOperator(BinaryOperator<T> binaryOperator, T a, T b) {
        return binaryOperator.apply(a, b);
    }

    public static <T, R> R usingFunctionAsPredicate(Function<T, R> prediFunction, T a) {
        return prediFunction.apply(a);
    }

    public static <T> void printData(Consumer<T> consumer, T a) {
        /*
         * Prints the data, (List.of()) using a for loop inside of lambda function.
         */
        consumer.accept(a);
    }

    public static String getRandomOne(String[] arr, Supplier<Integer> supplier) {
        return arr[supplier.get()];
    }

    @FunctionalInterface
    interface Concat<T> {
        T concat(T a, T b, T c);
    }
    public static <T> T usingCustomFunctionalInterface(Concat<T> concat, T a, T b, T c) {
        return concat.concat(a, b, c);
    }


}

最終判決

Java 中的函數式介面是簡化程式碼和提高可讀性的強大工具。無論您是處理集合、執行轉換還是處理資料流，這些介面都可以讓您更輕鬆地定義簡潔的操作。

透過理解和應用 Consumer、Predicate、Function、Supplier 和自訂介面等函數式接口，您可以充分利用 Java 的函數式程式設計功能。

以上是Java 中的預設函數式介面的詳細內容。更多資訊請關注PHP中文網其他相關文章！