Java 中的默认函数式接口

从现在开始，我们要努力学习啦！今天我给大家带来《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  void usingConsumer(Consumer consumer, T a) {
        // Method that takes consumer interface will return void.
        // Can print something constituting 'a'
        consumer.accept(a);
    }

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

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

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

    public static  R usingFunction(Function 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  R usingBiFunction(BiFunction biFunction, T a, U b) {
        return biFunction.apply(a, b);
    }

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

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

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

    public static  void printData(Consumer 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 supplier) {
        return arr[supplier.get()];
    }

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


}

最终判决

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

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

今天关于《Java 中的默认函数式接口》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！