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


}


</t></t></t></integer></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t>

最终判决

java 中的函数式接口是简化代码和提高可读性的强大工具。无论您是处理集合、执行转换还是处理数据流，这些接口都可以让您更轻松地定义简洁的操作。

通过理解和应用 consumer、predicate、function、supplier 和自定义接口等函数式接口，您可以充分利用 java 的函数式编程功能。

以上就是Java 中的默认函数式接口的详细内容，更多请关注其它相关文章！