函数式接口
Posted 学无止路
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了函数式接口相关的知识，希望对你有一定的参考价值。
1 函数式接口
1.1 概念
函数式接口在Java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。
备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。
1.2 格式
只要确保接口中有且仅有一个抽象方法即可：
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
}
由于接口当中抽象方法的public abstract 是可以省略的，所以定义一个函数式接口很简单：
1.3 @FunctionalInterface注解
与@Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解：@FunctionalInterface 。该注
解可用于一个接口的定义上：
一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注
意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。
1.4 自定义函数式接口
对于刚刚定义好的MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数。
Java代码如下：
/** 函数式接口:有且只有一个抽象方法的接口,称之为函数式接口 当然接口中可以包含其他的方法(默认,静态,私有) @FunctionalInterface注解 作用:可以检测接口是否是一个函数式接口 是:编译成功 否:编译失败(接口中没有抽象方法抽象方法的个数多余1个) */ @SuppressWarnings("all") // 注解警告信息 @FunctionalInterface public interface MyFunctionalInterface { //定义一个抽象方法 public abstract void method(); } |
/** @Override注解 检查方法是否为重写的方法 是:编译成功 否:编译失败 */ @SuppressWarnings("all") // 注解警告信息 public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{ @Override public void method() { } /*@Override public void method2() { }*/ /*@Override public void method3() { }*/ } |
测试类代码如下：
/** 函数式接口的使用:一般可以作为方法的参数和返回值类型 */ @SuppressWarnings("all") // 注解警告信息 public class Demo { // 定义一个方法,参数使用函数式接口MyFunctionalInterface public static void show(MyFunctionalInterface myInter){ myInter.method(); } public static void main(String[] args) { // 调用show方法,方法的参数是一个接口,所以可以传递接口的实现类对象 show(new MyFunctionalInterfaceImpl()); // 调用show方法,方法的参数是一个接口,所以我们可以传递接口的匿名内部类 show(new MyFunctionalInterface() { @Override public void method() { System.out.println("使用匿名内部类重写接口中的抽象方法"); } }); // 调用show方法,方法的参数是一个函数式接口,所以我们可以Lambda表达式 show(()->{ System.out.println("使用Lambda表达式重写接口中的抽象方法"); }); // 简化Lambda表达式 show(()-> System.out.println("使用Lambda表达式重写接口中的抽象方法")); } } |
2 函数式编程
在兼顾面向对象特性的基础上，Java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。
下面我们做一个初探。
2.1 Lambda的延迟执行
public interface MyFunctionalInterface {
void myMethod();
}
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
public class Demo09FunctionalInterface {
// 使用自定义的函数式接口作为方法参数
private static voiddoSomething(MyFunctionalInterface inter) {
inter.myMethod(); // 调用自定义的函数式接口方法
}
public static void main(String[] args) {
// 调用使用函数式接口的方法
doSomething(() ‐>System.out.println("Lambda执行啦！"));
}
}
有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以
作为解决方案，提升性能。
性能浪费的日志案例
注:日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。
一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：
这段代码存在问题：无论级别是否满足要求，作为log 方法的第二个参数，三个字符串一定会首先被拼接并传入方
法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。
备注：SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行
字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进
行字符串拼接。例如：LOGGER.debug("变量{}的取值为{}。", "os","macOS") ，其中的大括号{} 为占位
符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字
符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。
体验Lambda的更优写法
使用Lambda必然需要一个函数式接口：
然后对log 方法进行改造：
public class Demo01Logger {
private static void log(int level, Stringmsg) {
if (level == 1) {
System.out.println(msg);
}
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(1, msgA + msgB + msgC);
}
}
@FunctionalInterface
public interface MessageBuilder {
String buildMessage();
}
public class Demo02LoggerLambda {
private static void log(int level,MessageBuilder builder) {
if (level == 1) {
System.out.println(builder.buildMessage());
}
}
这样一来，只有当级别满足要求的时候，才会进行三个字符串的拼接；否则三个字符串将不会进行拼接。
证明Lambda的延迟
下面的代码可以通过结果进行验证：
从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。
扩展：实际上使用内部类也可以达到同样的效果，只是将代码操作延迟到了另外一个对象当中通过调用方法
来完成。而是否调用其所在方法是在条件判断之后才执行的。
2.2 使用Lambda作为参数和返回值
如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数
式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式
接口作为方法参数。
例如java.lang.Runnable 接口就是一个函数式接口，假设有一个startThread方法使用该接口作为参数，那么就
可以使用Lambda进行传参。这种情况其实和Thread 类的构造方法参数为Runnable 没有本质区别。
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(1, () ‐> msgA + msgB + msgC );
}
}
public class Demo03LoggerDelay {
private static void log(int level,MessageBuilder builder) {
if (level == 1) {
System.out.println(builder.buildMessage());
}
}
public static void main(String[] args) {
String msgA = "Hello";
String msgB = "World";
String msgC = "Java";
log(2, () ‐> {
System.out.println("Lambda执行！");
return msgA + msgB + msgC;
});
}
}
类似地，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时,就可以调该方法获取。
其中直接return一个Lambda表达式即可。
Java代码如下：
@SuppressWarnings("all") // 注解警告信息 @FunctionalInterface public interface MessageBuilder { // 定义一个拼接消息的抽象方法,返回被拼接的消息 public abstract String builderMessage(); } |
/** 使用Lambda优化日志案例 Lambda的特点:延迟加载 Lambda的使用前提,必须存在函数式接口 */ @SuppressWarnings("all") // 注解警告信息 public class Demo02Lambda { // 定义一个显示日志的方法,方法的参数传递日志的等级和MessageBuilder接口 public static void showLog(int level, MessageBuilder mb){ //对日志的等级进行判断,如果是1级,则调用MessageBuilder接口中的builderMessage方法 if(level==1){ System.out.println(mb.builderMessage()); } } public static void main(String[] args) { // 定义三个日志信息 String msg1 = "Hello"; String msg2 = "World"; String msg3 = "Java"; // 调用showLog方法,参数MessageBuilder是一个函数式接口,所以可以传递Lambda表达式 /*showLog(2,()->{ //返回一个拼接好的字符串 return msg1+msg2+msg3; });*/ /* 使用Lambda表达式作为参数传递,仅仅是把参数传递到showLog方法中 只有满足条件,日志的等级是1级 才会调用接口MessageBuilder中的方法builderMessage 才会进行字符串的拼接 如果条件不满足,日志的等级不是1级 那么MessageBuilder接口中的方法builderMessage也不会执行 所以拼接字符串的代码也不会执行 所以不会存在性能的浪费 */ showLog(1,()->{ System.out.println("不满足条件不执行"); // 返回一个拼接好的字符串 return msg1+msg2+msg3; }); } } |
测试类代码如下：
/** 日志案例 发现以下代码存在的一些性能浪费的问题 调用showLog方法,传递的第二个参数是一个拼接后的字符串 先把字符串拼接好,然后在调用showLog方法 showLog方法中如果传递的日志等级不是1级 那么就不会是如此拼接后的字符串 所以感觉字符串就白拼接了,存在了浪费 */ @SuppressWarnings("all") // 注解警告信息 public class Demo01Logger { // 定义一个根据日志的级别,显示日志信息的方法 public static void showLog(int level, String message){ // 对日志的等级进行判断,如果是1级别,那么输出日志信息 if(level==1){ System.out.println(message); } } public static void main(String[] args) { // 定义三个日志信息 String msg1 = "Hello"; String msg2 = "World"; String msg3 = "Java"; // 调用showLog方法,传递日志级别和日志信息 showLog(2,msg1+msg2+msg3); } } |
2.3 练习
例如java.lang.Runnable接口就是一个函数式接口，假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参。
这种情况其实和Thread类的构造方法参数为Runnable没有本质区别。实现代码：
/** 如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。 当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时,就可以调该方法获取。 */ @SuppressWarnings("all") // 注解警告信息 public class Demo02Comparator { // 定义一个方法,方法的返回值类型使用函数式接口Comparator public static Comparator<String> getComparator(){ // 方法的返回值类型是一个接口,那么我们可以返回这个接口的匿名内部类 /*return new Comparator<String>() { @Override public int compare(String o1, String o2) { //按照字符串的降序排序 return o2.length()-o1.length(); } };*/ // 方法的返回值类型是一个函数式接口,所有我们可以返回一个Lambda表达式 /*return (String o1, String o2)->{ //按照字符串的降序排序 return o2.length()-o1.length(); };*/ // 继续优化Lambda表达式 return (o1, o2)->o2.length()-o1.length(); } public static void main(String[] args) { // 创建一个字符串数组 String[] arr = {"aaa","b","cccccc","dddddddddddd"}; // 输出排序前的数组 System.out.println(Arrays.toString(arr)); // [aaa, b, cccccc, dddddddddddd] // 调用Arrays中的sort方法,对字符串数组进行排序 Arrays.sort(arr,getComparator()); // 输出排序后的数组 System.out.println(Arrays.toString(arr)); // [dddddddddddd, cccccc, aaa, b] } } |
测试类代码如下：
/** 例如java.lang.Runnable接口就是一个函数式接口， 假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda进行传参。 这种情况其实和Thread类的构造方法参数为Runnable没有本质区别。 */ @SuppressWarnings("all") // 注解警告信息 public class Demo01Runnable { // 定义一个方法startThread,方法的参数使用函数式接口Runnable public static void startThread(Runnable run){ // 开启多线程 new Thread(run).start(); } public static void main(String[] args) { // 调用startThread方法,方法的参数是一个接口,那么我们可以传递这个接口的匿名内部类 startThread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了"); } }); // 调用startThread方法,方法的参数是一个函数式接口,所以可以传递Lambda表达式 startThread(()->{ System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了"); }); // 优化Lambda表达式 startThread(()->System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了")); } } |
3 常用函数式接口
JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在java.util.function 包中被提供。
下面是最简单的几个接口及使用示例。
3.1 Supplier接口
java.util.function.Supplier<T> 接口仅包含一个无参的方法：T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
Java代码如下：
/** 常用的函数式接口 java.util.function.Supplier<T>接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。 Supplier<T>接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据 */ @SuppressWarnings("all") // 注解警告信息 public class Demo01Supplier { // 定义一个方法,方法的参数传递Supplier<T>接口,泛型执行String,get方法就会返回一个String public static String getString(Supplier<String> sup){ return sup.get(); } public static void main(String[] args) { // 调用getString方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式 String s = getString(()->{ // 生产一个字符串,并返回 return "胡歌"; }); System.out.println(s); // 优化Lambda表达式 String s2 = getString(()->"胡歌"); System.out.println(s2); } } |
3.2 练习：求数组元素最大值
题目
使用Supplier 接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。提示：接口的泛型请使用
Java代码如下：
/** 练习：求数组元素最大值 使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。 提示：接口的泛型请使用java.lang.Integer类。 */ @SuppressWarnings("all") // 注解警告信息 class Demo02Test { // 定义一个方法,用于获取int类型数组中元素的最大值,方法的参数传递Supplier接口,泛型使用Integer public static int getMax(Supplier<Integer> sup){ return sup.get(); } public static void main(String[] args) { // 定义一个int类型的数组,并赋值 int[] arr = {100,0,-50,880,99,33,-30}; // 调用getMax方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式 int maxValue = getMax(()->{ // 获取数组的最大值,并返回 // 定义一个变量,把数组中的第一个元素赋值给该变量,记录数组中元素的最大值 int max = arr[0]; // 遍历数组,获取数组中的其他元素 for (int i : arr) { // 使用其他的元素和最大值比较 if(i>max){ // 如果i大于max,则替换max作为最大值 max = i; } } // 返回最大值 return max; }); System.out.println("数组中元素的最大值是:"+maxValue); } } |
3.3 Consumer接口
java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。
抽象方法：accept
Consumer 接口中包含抽象方法voidaccept(T t) ，意为消费一个指定泛型的数据。基本使用如：
当然，更好的写法是使用方法引用。
默认方法：andThen
如果一个方法的参数和返回值全都是Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是Consumer 接口中的default方法andThen 。下面是JDK的源代码：
备注：java.util.Objects 的requireNonNull 静态方法将会在参数为null时主动抛出
NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦。
要想实现组合，需要两个或多个Lambda表达式即可，而andThen 的语义正是“一步接一步”操作。例如两个步骤组合的情况：
/** java.util.function.Consumer<T>接口则正好与Supplier接口相反， 它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。 Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。 Consumer接口是一个消费型接口,泛型执行什么类型,就可以使用accept方法消费什么类型的数据 至于具体怎么消费(使用),需要自定义(输出,计算....) */ @SuppressWarnings("all") // 注解警告信息 public class Demo01Consumer { /* 定义一个方法 方法的参数传递一个字符串的姓名 方法的参数传递Consumer接口,泛型使用String 可以使用Consumer接口消费字符串的姓名 */ public static void method(String name, Consumer<String> con){ con.accept(name); } public static void main(String[] args) { // 调用method方法,传递字符串姓名,方法的另一个参数是Consumer接口,是一个函数式接口,所以可以传递Lambda表达式 method("赵丽颖",(String name)->{ // 对传递的字符串进行消费 // 消费方式:直接输出字符串 // System.out.println(name); // 消费方式:把字符串进行反转输出 String reName = new StringBuffer(name).reverse().toString(); System.out.println(reName); }); } } |
Consumer接口的默认方法andThen的代码如下：
/** Consumer接口的默认方法andThen 作用:需要两个Consumer接口,可以把两个Consumer接口组合到一起,在对数据进行消费 例如: Consumer<String> con1 Consumer<String> con2 String s = "hello"; con1.accept(s); con2.accept(s); 连接两个Consumer接口 再进行消费 con1.andThen(con2).accept(s); 谁写前边谁先消费 */ @SuppressWarnings("all") // 注解警告信息 public class Demo02AndThen { // 定义一个方法,方法的参数传递一个字符串和两个Consumer接口,Consumer接口的泛型使用字符串 public static void method(String s, Consumer<String> con1 ,Consumer<String> con2){ // con1.accept(s); // con2.accept(s); // 使用andThen方法,把两个Consumer接口连接到一起,在消费数据 con1.andThen(con2).accept(s);//con1连接con2,先执行con1消费数据,在执行con2消费数据 } public static void main(String[] args) { // 调用method方法,传递一个字符串,两个Lambda表达式 method("Hello", (t)->{ // 消费方式:把字符串转换为大写输出 System.out.println(t.toUpperCase()); }, (t)->{ // 消费方式:把字符串转换为小写输出 System.out.println(t.toLowerCase()); }); } } |
3.4 练习：格式化打印信息
题目
下面的字符串数组当中存有多条信息，请按照格式“姓名：XX。性别：XX。”的格式将信息打印出来。要求将打印姓名的动作作为第一个Consumer 接口的Lambda实例，将打印性别的动作作为第二个Consumer 接口的Lambda实
例，将两个Consumer 接口按照顺序“拼接”到一起。
Java代码如下：
/** 练习: 字符串数组当中存有多条信息，请按照格式“姓名：XX。性别：XX。”的格式将信息打印出来。 要求将打印姓名的动作作为第一个Consumer接口的Lambda实例， 将打印性别的动作作为第二个Consumer接口的Lambda实例， 将两个Consumer接口按照顺序“拼接”到一起。 */ @SuppressWarnings("all") // 注解警告信息 public class Demo03Test { // 定义一个方法,参数传递String类型的数组和两个Consumer接口,泛型使用String public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){ // 遍历字符串数组 for (String message : arr) { // 使用andThen方法连接两个Consumer接口,消费字符串 con1.andThen(con2).accept(message); } } public static void main(String[] args) { // 定义一个字符串类型的数组 String[] arr = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" }; // 调用printInfo方法,传递一个字符串数组,和两个Lambda表达式 printInfo(arr,(message)->{ // 消费方式:对message进行切割,获取姓名,按照指定的格式输出 String name = message.split(",")[0]; System.out.print("姓名: "+name); },(message)->{ // 消费方式:对message进行切割,获取年龄,按照指定的格式输出 String age = message.split(",")[1]; System.out.println("。年龄: "+age+"。"); }); } } |
3.5 Predicate接口
有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用
java.util.function.Predicate<T> 接口。
抽象方法：test
Predicate 接口中包含一个抽象方法：boolean test(T t) 。用于条件判断的场景：
Java代码如下：
/** java.util.function.Predicate<T>接口 作用:对某种数据类型的数据进行判断,结果返回一个boolean值 Predicate接口中包含一个抽象方法： boolean test(T t):用来对指定数据类型数据进行判断的方法 结果: 符合条件,返回true 不符合条件,返回false */ @SuppressWarnings("all") // 注解警告信息 public class Demo01Predicate { /* 定义一个方法 参数传递一个String类型的字符串 传递一个Predicate接口,泛型使用String 使用Predicate中的方法test对字符串进行判断,并把判断的结果返回 */ public static boolean checkString(String s, Predicate<String> pre){ return pre.test(s); } public static void main(String[] args) { // 定义一个字符串 String s = "abcdef"; // 调用checkString方法对字符串进行校验,参数传递字符串和Lambda表达式 /*boolean b = checkString(s,(String str)->{ //对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回 return str.length()>5; });*/ // 优化Lambda表达式 boolean b = checkString(s,str->str.length()>5); System.out.println(b); } } |
条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。
默认方法：and既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法and 。其JDK源码为：如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：默认方法：or与and 的“与”类似，默认方法or 实现逻辑关系中的“或”。JDK源码为：
如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将“and”修改为“or”名称即可，其他都不变：默认方法：negate“与”、“或”已经了解了，剩下的“非”（取反）也会简单。默认方法negate的JDK源代码为：从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在test 方法调用之前调用negate 方法，正如and 和or 方法一样：
Java代码1下：
/** 逻辑表达式:可以连接多个判断的条件 &&:与运算符,有false则false ||:或运算符,有true则true !:非(取反)运算符,非真则假,非假则真 需求:判断一个字符串,有两个判断的条件 1.判断字符串的长度是否大于5 2.判断字符串中是否包含a 两个条件必须同时满足,我们就可以使用&&运算符连接两个条件 Predicate接口中有一个方法and,表示并且关系,也可以用于连接两个判断条件 default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> this.test(t) && other.test(t); } 方法内部的两个判断条件,也是使用&&运算符连接起来的 */ @SuppressWarnings("all") // 注解警告信息 public class Demo02Predicate_and { /* 定义一个方法,方法的参数,传递一个字符串 传递两个Predicate接口 一个用于判断字符串的长度是否大于5 一个用于判断字符串中是否包含a 两个条件必须同时满足 */ public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){ // return pre1.test(s) && pre2.test(s); return pre1.and(pre2).test(s); // 等价于return pre1.test(s) && pre2.test(s); } public static void main(String[] args) { // 定义一个字符串 String s = "abcdef"; // 调用checkString方法,参数传递字符串和两个Lambda表达式 boolean b = checkString(s,(String str)->{ // 判断字符串的长度是否大于5 return str.length()>5; },(String str)->{ // 判断字符串中是否包含a return str.contains("a"); }); System.out.println(b); } } |
Java代码2如下：
/** 需求:判断一个字符串,有两个判断的条件 1.判断字符串的长度是否大于5 2.判断字符串中是否包含a 满足一个条件即可,我们就可以使用||运算符连接两个条件 Predicate接口中有一个方法or,表示或者关系,也可以用于连接两个判断条件 default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); } 方法内部的两个判断条件,也是使用||运算符连接起来的 */ @SuppressWarnings("all") // 注解警告信息 public class Demo03Predicate_or { /* 定义一个方法,方法的参数,传递一个字符串 传递两个Predicate接口 一个用于判断字符串的长度是否大于5 一个用于判断字符串中是否包含a 满足一个条件即可 */ public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){ // return pre1.test(s) || pre2.test(s); return pre1.or(pre2).test(s);// 等价于return pre1.test(s) || pre2.test(s); } public static void main(String[] args) { // 定义一个字符串 String s = "bc"; // 调用checkString方法,参数传递字符串和两个Lambda表达式 boolean b = checkString(s,(String str)->{ // 判断字符串的长度是否大于5 return str.length()>5; },(String str)->{ // 判断字符串中是否包含a return str.contains("a"); }); System.out.println(b); } } |
Java代码3如下：
/** 需求:判断一个字符串长度是否大于5 如果字符串的长度大于5,那返回false 如果字符串的长度不大于5,那么返回true 所以我们可以使用取反符号!对判断的结果进行取反 Predicate接口中有一个方法negate,也表示取反的意思 default Predicate<T> negate() { return (t) -> !test(t); } */ @SuppressWarnings("all") // 注解警告信息 public class Demo04Predicate_negate { /* 定义一个方法,方法的参数,传递一个字符串 使用Predicate接口判断字符串的长度是否大于5 */ public static boolean checkString(String s, Predicate<String> pre){ // return !pre.test(s); return pre.negate().test(s); // 等效于return !pre.test(s); } public static void main(String[] args) { // 定义一个字符串 String s = "abc"; // 调用checkString方法,参数传递字符串和Lambda表达式 boolean b = checkString(s,(String str)->{ // 判断字符串的长度是否大于5,并返回结果 return str.length()>5; }); System.out.println(b); } } |
3.6 练习：集合信息筛选
题目
·数组当中有多条“姓名+性别”的信息如下，请通过Predicate 接口的拼装将符合要求的字符串筛选到集合
ArrayList 中，需要同时满足两个条件：
1. 必须为女生；
2. 姓名为4个字。
Java代码如下：
/** 练习：集合信息筛选 数组当中有多条“姓名+性别”的信息如下， String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" }; 请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中， 需要同时满足两个条件： 1. 必须为女生； 2. 姓名为4个字。 分析: 1.有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断 2.必须同时满足两个条件,所以可以使用and方法连接两个判断条件 */ @SuppressWarnings("all") // 注解警告信息 public class Demo05Test { /* 定义一个方法 方法的参数传递一个包含人员信息的数组 传递两个Predicate接口,用于对数组中的信息进行过滤 把满足条件的信息存到ArrayList集合中并返回 */ public static ArrayList<String> filter(String[] arr,Predicate<String> pre1,Predicate<String> pre2){ // 定义一个ArrayList集合,存储过滤之后的信息 ArrayList<String> list = new ArrayList<>(); // 遍历数组,获取数组中的每一条信息 for (String s : arr) { // 使用Predicate接口中的方法test对获取到的字符串进行判断 boolean b = pre1.and(pre2).test(s); // 对得到的布尔值进行判断 if(b){ // 条件成立,两个条件都满足,把信息存储到ArrayList集合中 list.add(s); } } // 把集合返回 return list; } public static void main(String[] args) { // 定义一个储存字符串的数组 String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" }; // 调用filter方法,传递字符串数组和两个Lambda表达式 ArrayList<String> list = filter(array,(String s)->{ // 获取字符串中的性别,判断是否为女 return s.split(",")[1].equals("女"); },(String s)->{ // 获取字符串中的姓名,判断长度是否为4个字符 return s.split(",")[0].length()==4; }); // 遍历集合 for (String s : list) { System.out.println(s); } } } |
3.7 Function接口
java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。
抽象方法：apply
Function 接口中最主要的抽象方法为：R apply(T t) ，根据类型T的参数获取类型R的结果。
使用的场景例如：将String 类型转换为Integer 类型。
/** java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据， 前者称为前置条件，后者称为后置条件。 Function接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。 使用的场景例如：将String类型转换为Integer类型。 */ @SuppressWarnings("all") // 注解警告信息 public class Demo01Function { /** 定义一个方法 方法的参数传递一个字符串类型的整数 方法的参数传递一个Function接口,泛型使用<String,Integer> 使用Function接口中的方法apply,把字符串类型的整数,转换为Integer类型的整数 */ public static void change(String s, Function<String,Integer> fun){ // Integer in = fun.apply(s); int in = fun.apply(s); // 自动拆箱 Integer->int System.out.println(in); } public static void main(String[] args) { // 定义一个字符串类型的整数 String s = "1234"; // 调用change方法,传递字符串类型的整数,和Lambda表达式 change(s,(String str)->{ // 把字符串类型的整数,转换为Integer类型的整数返回 return Integer.parseInt(str); }); // 优化Lambda change(s,str->Integer.parseInt(str)); } } |
当然，最好是通过方法引用的写法。
默认方法：andThen
Function 接口中有一个默认的andThen 方法，用来进行组合操作。JDK源代码如：
该方法同样用于“先做什么，再做什么”的场景，和Consumer 中的andThen 差不多：
第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过andThen 按照前后顺序组合到了一起。
请注意，Function的前置条件泛型和后置条件泛型可以相同。
Java代码如下：
/** Function接口中的默认方法andThen:用来进行组合操作 需求: 把String类型的"123",转换为Inteter类型,把转换后的结果加10 把增加之后的Integer类型的数据,转换为String类型 分析: 转换了两次 第一次是把String类型转换为了Integer类型 所以我们可以使用Function<String,Integer> fun1 Integer i = fun1.apply("123")+10; 第二次是把Integer类型转换为String类型 所以我们可以使用Function<Integer,String> fun2 String s = fun2.apply(i); 我们可以使用andThen方法,把两次转换组合在一起使用 String s = fun1.andThen(fun2).apply("123"); fun1先调用apply方法,把字符串转换为Integer fun2再调用apply方法,把Integer转换为字符串 */ public class Demo02Function_andThen { /** 定义一个方法 参数串一个字符串类型的整数 参数再传递两个Function接口 一个泛型使用Function<String,Integer> 一个泛型使用Function<Integer,String> */ public static void change(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){ String ss = fun1.andThen(fun2).apply(s); System.out.println(ss); } public static void main(String[] args) { // 定义一个字符串类型的整数 String s = "123"; // 调用change方法,传递字符串和两个Lambda表达式 change(s,(String str)->{ // 把字符串转换为整数+10 return Integer.parseInt(str)+10; },(Integer i)->{ // 把整数转换为字符串 return i+""; }); // 优化Lambda表达式 change(s,str->Integer.parseInt(str)+10,i->i+""); } } |
3.8 练习：自定义函数模型拼接
题目
请使用Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str = "赵丽颖,20";
/** 练习：自定义函数模型拼接 题目 请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为： String str = "赵丽颖,20"; 分析: 1. 将字符串截取数字年龄部分，得到字符串； Function<String,String> "赵丽颖,20"->"20" 2. 将上一步的字符串转换成为int类型的数字； Function<String,Integer> "20"->20 3. 将上一步的int数字累加100，得到结果int数字。 Function<Integer,Integer> 20->120 */ public class Demo03Test { /** 定义一个方法 参数传递包含姓名和年龄的字符串 参数再传递3个Function接口用于类型转换 */ public static int change(String s, Function<String,String> fun1, Function<String,Integer> fun2,Function<Integer,Integer> fun3){ // 使用andThen方法把三个转换组合到一起 return fun1.andThen(fun2).andThen(fun3).apply(s); } public static void main(String[] args) { // 定义一个字符串 String str = "赵丽颖,20"; // 调用change方法,参数传递字符串和3个Lambda表达式 int num = change(str,(String s)->{ //"赵丽颖,20"->"20" return s.split(",")[1]; },(String s)->{ // "20"->20 return Integer.parseInt(s); },(Integer i)->{ // 20->120 return i+100; }); System.out.println(num); } } |
以上是关于函数式接口的主要内容，如果未能解决你的问题，请参考以下文章