函数式接口

Lambda表达式需要接口的支持，并且接口的抽象方法还只能有一个，要么没法区分实现的是哪一个抽象方法了。因此Lambda表达式需要函数式接口的支持

什么是函数式接口

接口中只有一个抽象方法的接口称为函数式接口。

函数式接口可以使用一个注解@FunctionalInterface修饰，此注解可以检查是否是函数式接口

函数式接口的使用

假设我们现在有一个需求：对一个数进行运算，什么运算都可以。如果我们想用Lambda表达式来实现的话，我们就需要一个接口来支持，下面我们先写一个MyFunction接口

@FunctionalInterface
public interface MyFunction {
    public Integer getValue(Integer num);
}

然后我们需要一个运算的方法

    //运算方法
    public Integer operation(Integer num, MyFunction fun){
        return fun.getValue(num);
    }

测试类

    @Test
    public void test06(){
        //平方运算
        Integer num = operation(10,(x) -> x*x);
        System.out.println(num);
        //加和运算
        Integer num2 = operation(100,(y) -> y+200);
        System.out.println(num2);

    }

执行结果

100
300

不管是什么运算，我们只需要关注Lambda表达式的方法体如何实现运算就可以了。

通过以上例子发现，如果我们想用Lambda表达式来实现的话，我们就需要写一个接口来支持，是不是也挺麻烦的，其实，一般我们常用的接口，Java8里基本都已经给我们提供了，下面来看下Java8内置的核心接口。

Java8内置的四大核心函数式接口

一、Consumer<T>：消费型接口（void accept(T t)）

我们先看一下Java8中给我定义好的Consumer接口

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

然后我们自己写个简单的例子看一下，写个开开森森去消费的方法

    @Test
    public void test01(){
        happy("一消费就很开森啦啦啦",str -> System.out.println(str));
    }
    public void happy(String str,Consumer<String> consumer){
        consumer.accept(str);
    }

运行结果

一消费就很开森啦啦啦

以上就是消费型接口，消费即是有去无回，有参数无返回值类型的接口。

二、Supplier<T>：供给型接口（T get（））

我们先看一下Java8中给我定义好的Supplier接口

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

我们再来写个例子，写个方法产生指定个数的整数并放入集合中

    @Test
    public void test02(){
        List<Integer> numList = getValue(10,() -> (int)(Math.random()*100));
        for (Integer num :
                numList) {
            System.out.println(num);
        }
    }

    //产生指定个数的整数并放入集合中
    public List<Integer> getValue(int num,Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(supplier.get());
        }
        return list;
    }

执行结果

84
22
60
29
52
34
9
95
34
6

以上就是供给型接口，只有产出，没有输入，即只有返回值没有入参，给你产生一些对象，并返回给你。

三、Function : 函数型接口（R apply（T t））

Java8中函数式接口的定义

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
    
    ····后面代码省略了····
    }

下面写个处理字符串方法的例子

    @Test
    public void test03(){
        String returnStr = strHandler("\t\t\t我是一串有空格\t的字符串\t\t",(str) -> str.trim());
        System.out.println(returnStr);
    }

    public String strHandler(String str,Function<String,String> function){
        return function.apply(str);
    }

运行结果：trim()方法只是去除首尾的字符串

我是一串有空格 的字符串

以上就是一个函数型接口，一个参数，一个返回值，当然参数和返回值的类型可以相同

四、Predicate<T>：断言型接口（boolean test（T t））

Java8中断言型接口的定义如下

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
    ····后面到吗省略····
    }

下面我们写一个断言的例子，写个方法将满足条件的字符串放入集合中

    @Test
    public void test04(){
        List<String> list = Arrays.asList("aa","bbb","ccccc","dddddd");
        //长度大于3的字符串放入集合中
        List<String> reList = filterStr(list,(s) -> s.length() >3);
        for (String str: reList) {
            System.out.println(str);
        }
    }

    public List<String> filterStr(List<String> strList,Predicate<String> pre){
        List<String> list = new ArrayList<>();
        for (String str: strList) {
            if(pre.test(str)){
                list.add(str);
            }
        }
        return list;
    }

运行结果

ccccc
dddddd

以上是断言型接口，输入一个参数，输出一个boolean类型的返回值

五、其他类型的一些函数式接口

除了上面四种类型的核心接口还有一些其他的不常用的接口，我们可以了解一下

1. BiFunction<T, U, R>

• 类型：参数类型T，U返回类型R
• 用途：Function的子接口，对类型为T和U的参数应用操作，返回R类型的结果。包含有方法R apply(T t,U u)

2. UnaryOperator<T>(Function子接口)

• 类型：参数类型T,返回类型T
• 用途：Function的子接口，对类型为T的对象进行一元运算，并返回T类型的结果。包含有方法T apply(T t)

3. BinaryOperator<T>(BiFunction子接口)

• 类型：参数类型T，T,返回类型T
• 用途：BiFunction的子接口，对类型为T的对象进行二元运算，并返回T类型的结果。包含有方法T apply(T t1,T t2)

4. BiConsumcr(T, U)

• 类型：参数类型T, U,返回类型void
• 用途：Consumcr的子接口，对类型为T,U的参数应用操作。包含有方法void accept(T t,U u)

5. ToIntFunction<T>、ToLongFunction<T>、ToDoubleFunction<T>

• 类型：参数类型T,返回类型int long double
• 用途：分别计算int long double值的函数

6. IntFunction<R>、LongFunction<R>、DoubleFunction<R>

• 类型：参数类型int long double,返回类型T
• 用途：参数分别为int long double类型的函数

总结

以上就是Java8内置的核心接口，我们在使用的过程中，按需所取就ok啦。