JDK1.8函数式接口Function、Consumer、Pre

作者: 阿格琉斯的微笑 | 来源:发表于2019-11-27 17:08 被阅读0次

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>	无	T	供给型；无参，返回一个指定泛型的对象
Consumer<T>	T	无	消费型；传入一个指定泛型的参数，无返回值
Predicate<T>	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更改了，则编译会报错！

Image.png

4. Consumer：消费型函数式接口

使用场景：处理一些结果或数据，不需要返回的消费型，例如打印、发送通知等操作。
方法：

void accept(T t); 给参数T执行指定的操作
default Consumer<T> 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<T> and(Predicate<? super T> other) 与操作
Predicate<T> or(Predicate<? super T> other) 或操作
static <T> Predicate<T> 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()方法，验证结果并移除元素。

Image2.png

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);
    }

结果：

Image3.png

示例：使用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
<V> Function<V, R> compose(Function<? super V, ? extends T> before) 组合函数，调用当前function之前调用
<V> Function<T, V> andThen(Function<? super R, ? extends V> after) 组合函数，调用当前function之后调用
static <T> 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

JDK1.8函数式接口Function、Consumer、Pre