JDK1.8函数式接口Function、Consumer、Predicate、Supplier
1. 函数式接口定义
函数式接口（Functional Interface）：有且仅有一个抽象方法的接口，但可以有多个非抽象方法的接口
函数式接口，即适用于函数式编程场景的接口，可以被隐式转换为Lambda表达式来表示接口的一个实现；jdk8以前是使用匿名类实现的。
示例：jdk1.8 使用注解@FunctionalInterface注解表示一个函数式接口
package com.agger.springbootfunction.function;
/**
* @classname: IHello
* @description: 函数式接口（只有一个抽象接口），使用@FunctionalInterface注解表示
* @author chenhx
* @date 2019-11-27 10:22:23
*/
@FunctionalInterface
public interface IHello {
public void sayHello(String name);
}
示例: jdk1.8 之前使用匿名类方式来调用函数式接口
/**
* @Title: test1
* @Description: jdk1.8 之前使用匿名类方式来调用函数式接口
* @author chenhx
* @date 2019-11-27 10:33:50
*/
@Test
void test1() {
IHello hello = new IHello() {
@Override
public void sayHello(String name) {
System.out.println("hello " + name);
}
};
hello.sayHello("张三");
}
示例: jdk1.8 之后可以使用lambda表达式隐式的实现函数式接口
/**
* @Title: test2
* @Description: jdk1.8 后可以使用lambda表达式隐式的实现函数式接口
* @author chenhx
* @date 2019-11-27 10:47:02
*/
@Test
void test2() {
IHello hello = name -> System.out.println("hello " + name);
hello.sayHello("李四");
}
2. jdk1.8 新增的函数式接口
jdk1.8之前,已有的函数式接口有很多, 参考 菜鸟教程:
- java.lang.Runnable
- java.util.concurrent.Callable
- java.security.PrivilegedAction
- java.util.Comparator
- java.io.FileFilter
- java.nio.file.PathMatcher
- java.lang.reflect.InvocationHandler
- java.beans.PropertyChangeListener
- java.awt.event.ActionListener
- javax.swing.event.ChangeListener
jdk1.8之后新增的一个重要的函数接口:
-
java.util.function
此包下有很多类来支持java的函数式编程, 现在就讲到本篇文章的重点, 其中重要的四个接口Function、Consumer、Predicate、Supplier。
| 接口 | 参数 | 返回值 | 说明 |
|---|---|---|---|
| Supplier | 无 | T | 供给型；无参，返回一个指定泛型的对象 |
| Consumer | T | 无 | 消费型；传入一个指定泛型的参数，无返回值 |
| Predicate | T | Boolean | 断言型；判断函数，返回判断结果true/false |
| Function<T,R> | T | R | 方法型；输入一个参数，得到一个结果 |
3. Supplier：供给型函数式接口
使用场景：提前定义可能返回的一个指定类型结果，等需要调用的时候再获取结果。
/**
* @Title: test3
* @Description: Supplier供给型函数式接口
* @author chenhx
* @date 2019-11-27 13:21:00
*/
@Test
void test3(){
// 示例1
int num1 = 100;
int num2 = 200;
// 提前定义好需要返回的指定类型结果，但不运行
Supplier<Integer> supplier= () -> num1 + num2;
// 调取get()方法获取一个结果
System.out.println(supplier.get());
// 示例2
String str = "abcdefghijklmn";
String s = getValue(()->str.substring(1,5));
System.out.println(s);
}
// 定义一个方法，返回一个结果，参数使用Supplier，具体返回内容由调用者决定
public static String getValue(Supplier<String> supplier){
return supplier.get();
}
注意：此示例中返回的结果引用的对象num1和num2其实是不能更改的，如果我们在supplier定义后，suppliser.get()调用前将num1或num更改了，则编译会报错！
4. Consumer：消费型函数式接口
使用场景：处理一些结果或数据，不需要返回的消费型，例如打印、发送通知等操作。
方法：
void accept(T t); 给参数T执行指定的操作
default Consumer andThen(Consumer<? super T> after) 给参数T执行指定操作后，再执行after方法
/**
* @Title: test4
* @Description:Consumer消费型函数式接口
* @author chenhx
* @date 2019-11-27 13:32:18
*/
@Test
void test4(){
// 传入一个加法并打印结果
modify(10,x->System.out.println(x+20));
// 传入一个减法并打印结果
modify(10,x->System.out.println(x-20));
}
// 定义一个方法，第二个参数为一个Consumer
public static void modify(int num,Consumer<Integer> consumer){
// 执行accept()方法，方法的具体实现不关心，调用的时候才关心
consumer.accept(num);
}
示例：将一批用户里面的“李四”整理出来。
/**
* @Title: test4
* @Description:Consumer消费型函数式接口
* @author chenhx
* @date 2019-11-27 13:32:18
*/
@Test
void test4(){
List<Person> lisiList = new ArrayList<>();
// 定义一个消费方法，将李四筛选出来存入lisiList
Consumer <Person> consumer = x -> {
if (x.getName().equals("李四")){
lisiList.add(x);
}
};
List<Person> list = new ArrayList<>();
list.add(new Person(21,"张三"));
list.add(new Person(22,"李四"));
list.add(new Person(23,"张三"));
list.add(new Person(16,"李四"));
list.add(new Person(30,"王五"));
list.add(new Person(52,"李四"));
// 传入一个消费方法
list.forEach(consumer);
// 打印消费方法处理后的lisiList
System.out.println(lisiList);
}
Consumer接口还有一个方法andThen(Consumer<? super T> after)，表示对给定参数执行定义操作后，再继续执行after定义的操作。
示例：将李四整理出来后将年龄大于25的李四整理出来
/**
* @Title: test4
* @Description:Consumer消费型函数式接口
* @author chenhx
* @date 2019-11-27 13:32:18
*/
@Test
void test4(){
List<Person> lisiList = new ArrayList<>();
// 定义一个消费方法，将李四筛选出来存入lisiList
Consumer <Person> consumer = x -> {
if (x.getName().equals("李四")){
lisiList.add(x);
}
};
// 整理出李四后，继续将年龄大于25的筛选出来
consumer = consumer.andThen(x->{
// removeIf方法里传入了一个Predicate断言接口实例，下面示例中将要讲到
lisiList.removeIf(y->y.getAge()<25);
});
List<Person> list = new ArrayList<>();
list.add(new Person(21,"张三"));
list.add(new Person(22,"李四"));
list.add(new Person(23,"张三"));
list.add(new Person(16,"李四"));
list.add(new Person(30,"王五"));
list.add(new Person(52,"李四"));
// 传入一个消费方法
list.forEach(consumer);
// 打印消费方法处理后的lisiList
System.out.println(lisiList);
}
5. Predicate：断言型函数式接口
使用场景：对一个数据进行判断，并返回boolean
方法：
- boolean test(T t) 判断指定值是否符合条件
- Predicate and(Predicate<? super T> other) 与操作
- Predicate or(Predicate<? super T> other) 或操作
- static Predicate isEqual(Object targetRef) 静态方法，equals判断第一个test与第二个test方法相同
/**
* @Title: test5
* @Description: Predicate断言型函数式接口
* @author chenhx
* @date 2019-11-27 15:01:55
*/
@Test
public void test5(){
Predicate<Integer> predicate = (x)-> x==10;
System.out.println(predicate.test(10));
}
在上例中我们有使用到List集合里的一个方法removeIf(Predicate<? super E> filter) 他的方法参数就是一个Predicate，用来判断list值并移除
示例：将list集合里面小于20的数据移除
/**
* @Title: test5
* @Description: Predicate断言型函数式接口
* @author chenhx
* @date 2019-11-27 15:01:55
*/
@Test
public void test5(){
List<Integer> list = new ArrayList<>();
list.add(9);
list.add(12);
list.add(21);
list.add(60);
// 使用lambda表达式Predicate，判断list里数是否满足条件，并删除
list.removeIf(x->x<20);
System.out.println(list);
}
查看list.removeIf()方法源码，我们发现他实现的方式就是遍历集合并对每个集合元素调用Predicate.test()方法，验证结果并移除元素。
Predicate其他方法的使用类似
示例：1.移除集合中大于20的元素。2.然后移除小于50的元素。3.或者移除值等于60的元素。4.前面整个结果取反
/**
* @Title: test5
* @Description: Predicate断言型函数式接口
* @author chenhx
* @date 2019-11-27 15:01:55
*/
@Test
public void test5(){
// 1.断言 值大于20
Predicate<Integer> predicate2 = (x)-> x>20;
// 2.断言 并且值小于50
predicate2 = predicate2.and(y->y<50);
// 3.断言 或者值等于60
predicate2 = predicate2.or(y->y==60);
// 4.断言 逻辑取反
predicate2 = predicate2.negate();
List<Integer> list = new ArrayList<>();
list.add(9);
list.add(12);
list.add(21);
list.add(60);
// 使用lambda表达式Predicate，判断list里数是否满足条件，并删除
list.removeIf(predicate2);
System.out.println(list);
}
结果：
示例：使用isEqual() 统计集合中与设定相等的元素个数
@Test
public void test5(){
// 示例3 统计集合中相等的对象的个数
Person p = new Person(22, "李四");
// 使用isEqual生成一个断言
Predicate<Person> predicate3 = Predicate.isEqual(p);
Long count = Stream.of(
new Person(21,"张三"),
new Person(22,"李四"),
new Person(23,"王五"),
new Person(24,"王五"),
new Person(22,"李四"),
new Person(26,"张三")
).filter(predicate3).count();
System.out.println(count);
}
结果：2
6. Function：函数型函数式接口
使用场景：根据一个数据类型得到另一个数据类型。
方法：
- R apply(T t); 根据一个数据类型T加工得到一个数据类型R
- Function<V, R> compose(Function<? super V, ? extends T> before) 组合函数，调用当前function之前调用
- Function<T, V> andThen(Function<? super R, ? extends V> after) 组合函数，调用当前function之后调用
- static Function<T, T> identity() 静态方法，返回与原函数参数一致的结果。x=y;
apply()
示例：实现一个function将String转换为Integer
/**
* @Title: test6
* @Description: Function函数型函数式接口
* @author chenhx
* @date 2019-11-27 16:18:50
*/
@Test
public void test6(){
//示例1：定义一个funciton,实现将String转换为Integer
Function<String,Integer> function = x->Integer.parseInt(x);
Integer a = function.apply("100");
System.out.println(a.getClass()); // 结果：class java.lang.Integer
}
andThen()
示例：使用andThen()方法实现一个函数：y=10x + 10
@Test
public void test6(){
//示例3：使用andThen() 实现一个函数 y=10x + 10;
Function<Integer,Integer> function2 = x->10*x;
function2 = function2.andThen(x->x+10);
System.out.println(function2.apply(2)); //结果：30
}
compose()
示例：使用compose() 实现一个函数 y=(10+x)2
@Test
public void test6(){
//示例4：使用compose() 实现一个函数 y=(10+x)2;
Function<Integer,Integer> function3 = x->x*2;
function3 = function3.compose(x->x+10);
System.out.println(function3.apply(3)); //结果：26
}
联合使用
示例：使用使用andThen()、compose() 方法实现一个函数 y=(10+x)2+10;
@Test
public void test6(){
//示例5：使用使用compose()、andThen()实现一个函数 y=(10+x)2+10;
Function<Integer,Integer> function4 = x->x*2;
function4 = function4.compose(x->x+10);
function4 = function4.andThen(x->x+10);
System.out.println(function4.apply(3)); //结果：36
}
7. 总结
这些函数式接口在我看来，用的最多的地方就是方法参数，向参数中传递一个函数，只有函数的定义，函数的具体实现则由调用者来实现。这就是函数式接口的意义所在。
参考文献：
https://www.jianshu.com/p/0b955173045e
https://blog.csdn.net/z834410038/article/details/77370785