Function函数式接口异常 Java java中函数式接口重要吗

函数式接口

一个接口中，有且只有一个抽象方法，这个接口就叫做函数式接口。常常使用@FunctionalInterface注解作为编译校验。满足函数式接口的要求，才能校验通过，否则会在校验阶段失败。
接口中有且只能有一个抽象方法，那么非默认方法，如default修饰的方法，可以有多个，这个没有限制。
函数式接口的作用就是函数式编程的入口，只有在函数式接口的抽象方法处写lamada表达式的函数式编程，java才能识别。所以说，函数式接口的出现就是为了Java能够使用函数式编程，而函数式编程的好处就是写法简单。这就是Java为何要引入函数式接口的意义。

自定义一个函数式接口，如下所示:

@FunctionalInterface
public interface IMyFunctional {

    //只能有一个抽象方法
    public  void demo();

}

在调用这个接口的抽象方法时，可以使用Lamada表达式来实现该抽象方法，如下所示:

//参数传函数式接口，方法里调用抽象方法
public static void show(IMyFunctional myFunctional){
        myFunctional.demo();
    }

在调用show方法时，可以用传统写法，定义匿名内部类，来实现接口的抽象方法，如下所示:

public static void main(String[] args) {
        show(new IMyFunctional() {
            @Override
            public void demo() {
                System.out.println("匿名内部类实现");
            }
        });
    }

可以使用函数式变成，用Lamada表达式来实现抽象方法，如下所示:

public static void main(String[] args) {
        show(()-> System.out.println("函数式编程实现"));
    }

常用函数式接口

Supplier接口

Supplier接口是生产接口，用于生产一个对象出来。

@FunctionalInterface
public interface Supplier<T> {

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

该接口抽象方法为get()方法，返回值为泛型类型的对象。通过该方法可以通过函数式编程获取一个对象。
例如，我们在定义某个方法时，需要传一个对象作为参数，通过这个对象，来执行一些操作，那么就可以通过Supplier接口来规定形参，然后通过Lamada表达式来生成需要的对象。如下所示:

public static void show(Supplier<String> stringSupplier){
        System.out.println(stringSupplier.get());
    }
public static void main(String[] args) {
       show(()->return UUID.fastUUID().toString());
    }

Consumer接口

Consumer接口是消费接口，传入一个参数后，对这个参数进行消费处理。
抽象方法如下:

void accept(T t);

当我们需要某个对象，进行处理的时候，可以使用Consumer接口作为形参，然后动态实现accept方法，进行对象处理的业务规定。

Consumer接口还定义了default方法，来形成消费链，可以执行多个消费者，对参数进行消费，源码如下:

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

Predicate接口

如果我们需要对某种类型的值进行判断，得到一个boolean类型的结果，可以使用Predicate接口。

boolean test(T t);

此外，该接口还提供了default默认方法，例如and()方法，or()方法等。代表同时满足and前后的条件才返回true。或满足or一个条件，就返回true。

Function接口

Function接口用于做类型转换，将T类型数据转换为R类型数据返回，抽象方法如下:

R apply(T t);

还提供了几个default默认方法，如下所示:

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

分析上述代码，首先，return返回值是一个Lamada表达式，为何用Lamada表达式呢，因为compose()方法返回值是Function，是一个函数式接口类型，用Lamada表达式就可以理解成是返回了Function的一个匿名内部类。Lamada表达式就是返回的Function对象的apply()方法的实现。

那么问题来了，apply方法的实现，怎么又调用了一个apply方法呢?调用的apply()方法里，又调用了before.apply()方法，这就相当于是嵌套了三层apply方法，看上去很乱，下面我们一层一层分析。

return的Lamada表达式是一层apply，代表compose()方法返回值Function的apply方法实现。在这个方法实现里，又调用了apply方法，这个第二层apply方法，是调用者的apply方法，即调用compose()的Function对象的apply方法，这个apply方法实现在哪定义呢？是我们自己的业务代码定义。然后第三层before.apply是参数的apply方法的调用，其实现也是我们业务代码去定义。

所以，当调用compose()方法返回的Function对象apply方法后，才会执行return 表达式的代码体。
下面看示例:

public static void show(Function<String,Integer> stringSupplier,Function<Integer,String> stringIntegerFunction){
        System.out.println("第三个执行");
        Function<Integer, Integer> compose = stringSupplier.compose(stringIntegerFunction);
        System.out.println("第四个执行");
        Integer apply = compose.apply(123);
        System.out.println(apply);
    }

public static void main(String[] args) {
        show((v)->{
            System.out.println("第一个执行");
            return Integer.valueOf(v);},(v)->{
            System.out.println("第二个执行");
            return v+"";});

    }

最终代码执行顺序如下:

根据上面的总结，Lamada表达式可以替换为匿名内部类，来返回一个编程式接口的实现类。

Stream流编程

Stream流式编程针对集合或数组对象进行，流式操作方法内部基本都是函数式接口作为参数，我们定义其抽象方法，来实现流式操作业务。常用方法有以下这些:

stream(): 集合或数组调用该方法，形成流对象。

forEach方法:

void forEach(Consumer<? super T> action);

可以看到是参数是Consumer接口，会将集合中元素都执行一遍Consumer方法的accept方法一遍，我们需要用Lamada表达式定义accept方法的业务即可。

filter方法:

Stream<T> filter(Predicate<? super T> predicate);

过滤方法，参数是Predicate接口，执行test()方法，返回boolean类型值，如果返回true则留下集合中元素，返回false则不留下集合中元素。

map方法:

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

参数为Function接口，对集合元素进行转换，转换成其他类型元素。

还有一些其他方法，如count() 计数方法，limit()方法，取前几个元素，skip()方法，跳过几个元素等等。

方法引用符

::为方法引用符，在Lamada表达式中，如果引用到外部对象的方法，那么可以简写为外部对象::对象方法，来简化lamada表达式。示例如下：

public static void show(IMyFunctional myFunctional){
        myFunctional.demo();
    }

public static void main(String[] args) {
        Demo demo=new Demo();
        show(()->demo.test() );
        //可以简写为: 对lamda表达式的简写，直接写成对象::方法，代表lamada表达式内内容
        show(demo::test);
    }