刚刚学习完 java 中的默认函数接口，我想把它们全部分享出来！
函数式接口是只有一种抽象方法的接口。如果您要处理 lambda 表达式（函数式编程），它们是必需的。它们简化了代码并广泛用于流中。虽然您可以创建自己的函数式接口，但当 java 为我们提供了一些重要的接口（例如 consumer、predicate、function 和supplier）时，为什么还要担心呢？
1. 消费者：
consumer 是一个函数式接口，表示接受单个输入参数且不返回结果的操作。它通常用于对给定参数执行操作（例如打印或记录）而不修改它。
签名：void accept(t t)（其中 t 是通用类型）
2. 谓词：
predicate 是一个函数式接口，表示返回布尔值的单个参数函数。它通常用于过滤或评估条件（例如，检查数字是否为偶数）。
签名：布尔测试(t t)
立即学习“Java免费学习笔记（深入）”；
3、功能：
function 是一种函数式接口，表示接受一个参数并产生结果的函数。它通常用于转换（例如，将一种类型转换为另一种类型或修改数据）。
签名：r apply(t t)
无错试用版，保留了所以商城的基本功能，商品数量限制80件2005V-C更新：更新所有订单功能及一些相应的错误，在线支付加上邮费功能支持在线支付八家银行等接口和可以选择商品图文排列功能，可以后台自由设置，银行接口列表如下：动感在线支付支付宝 网银在线 NPS支付 西部支付 1st-pay在线支付平台 首信易支付 易付通 中国在线支付 环讯IPS支付 不使用在线支付默认管理员帐号：admin密码：ad
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 的函数式编程功能。
