JDK1.8函数式接口Function、Consumer、Predicate、Supplier

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	方法型；输入一个参数，得到一个结果

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 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 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 other) 与操作
• Predicate or(Predicate 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 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 compose(Function before) 组合函数，调用当前function之前调用
• Function andThen(Function after) 组合函数，调用当前function之后调用
• static Function 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