函数式接口

简介

• 只包含一个抽象方法的接口，称为函数式接口
• 你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）
• 我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口

常见的函数式接口

• 消费型函数式接口 Consumer 常用于遍历 void accpet(T t)
• 供给型函数式接口 Supplier 用于产生数据 T get()
• 断言型函数式接口 Predicate 用于判断 boolean test(T t)
• 函数型函数式接口 Function<T,R> 用于逻辑处理 R apply(T t)

1.Supplier

源码：

该接口为一个供给型接口，抽象方法：T get()：该方法不需要参数，它会按照某种逻辑，返回一个具体的数据

注意：该接口也被称为生产型接口，如果指定了泛型是什么类型，那类中的get方法就会返回 一个该类型的一个具体数据。返回的数据，由该接口的实现类对象决定。
这里我们以一个计算数组的最大值为例，代码如下：

package com.wjf.lambda.fun;

import java.util.Arrays;
import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        fun1(()->{
            int arr[]={22,33,55,66,44,88,99};
            //计算出数组中的最大值
            Arrays.sort(arr);
            return arr[arr.length-1];
        });
    }
    private static void fun1(Supplier<Integer> supplier){
        //get()是一个无参的有返回值的
        Integer max = supplier.get();
        System.out.println("max="+max);
    }
}

2.Consumer

源码：

接口名称：Consumer

抽象方法：void accept(T t)：消费一个参数数据

概述：该接口中的方法可以接收一个参数，接收的参数类型由泛型指定，对参数的操作 方式根据该接口的实现类决定，不需要返回值。

拓展的非抽象方法：

default Consumer andThen(Consumer<? super T> after) ：

返回一个组合的 Consumer ，按顺序执行该操作，然后执行 after操作。

这里我们以一个字符串大小写转换为例：

package com.wjf.lambda.fun;

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        test((msg1)->{
            System.out.println(msg1+"->转换为小写："+msg1.toLowerCase());
        },(msg2)->{
            System.out.println(msg2+"->转换为大写："+msg2.toUpperCase());
        });
    }

    private static void test(Consumer<String> c1,Consumer<String> c2){
        String str="Hello World";
//        c1.accept(str);
//        c2.accept(str);
//        c1.andThen(c2).accept(str);
        c2.andThen(c1).accept(str);
    }

}

3.function

源码：

1、接口名：Function<T,R>
2、抽象方法：R apply(T)：接收一个数据，操作数据之后，返回一个新的数据
3、概述：
该接口可以接收一个数据，数据的类型根据泛型指定，然后通过该接口的实现类对象对 该数据进行操作，操作之后返回一个新的数据。
4、拓展的非抽象方法：default Function andThen(Function f)：
先通过调用者对象处理参数，将处理的结果再通过f对象处理，将两个处理的结果进行返回。

这里我以一个字符串转数字，然后数字再转数字为例:

package com.wjf.lambda.fun;

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        test((msg1)->{
            return Integer.parseInt(msg1);
        },(msg2)->{
            return msg2*10;
        });
    }

    public static void test(Function<String,Integer> f1,Function<Integer,Integer> f2){
//        Integer i1 = f1.apply("666");
//        Integer i2 = f2.apply(i1);
//        Integer i2 = f1.andThen(f2).apply("666");
        Integer i2 = f2.compose(f1).apply("666");
        System.out.println("i2="+i2);
    }
}

predicate

源码：

boolean test(T t)：对数据做出指定的判断

1、概述：

该接口是一个判断接口，接口可以接收一个指定泛型的参数，并根据该接口的实现类 对象对该参数做出对应的判断，返回只为boolean类型

2、额外功能：

and(Predicate p)：先将参数通过调用者判断真假，再将参数通过p判断真假，全真 为真，否则为假

or(Predicate p):全假为假，否则为真

negate():取反

这里我们以是否包含单个字母为例：

package com.wjf.lambda.fun;

import java.util.function.Predicate;

public class PredicateTest {
    public static void main(String[] args) {
        test((msg1)->{
            return msg1.contains("H");
        },(msg2)->{
            return msg2.contains("W");
        });
    }

    private static void test(Predicate<String> p1,Predicate<String> p2){
        //p1包含H p2包含W
        boolean bb1 = p1.and(p2).test("Hello");
        //p1包含H 或者 p2包含W
        boolean bb2 = p1.or(p2).test("Hello");
        //p1 不包含H
        boolean bb3 = p1.negate().test("Hello");
        System.out.println(bb1);
        System.out.println(bb2);
        System.out.println(bb3);
    }
}