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> 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

推荐阅读更多精彩内容