阅读数:92 评论数:0

一、函数式编程和非函数编程的区别

（1）函数式编程：先考虑传入的参数，再考虑方法的实现。

（2）非函数编程：先定义好方法，再传入指定的参数

二、何为函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法（不包括默认、静态），这样可以与lambda表达式配合，但是可以有多个非抽象方法的接口。它通过@FunctionalInterface注解标注,该注解可用于一个接口的定义上,一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

@FunctionalInterface
interface GreetingService 
{
    void sayMessage(String message);
    
    void doOtherWork(){
    	// Method body
    }
    
     void doOtherWork2(){
    	// Method body
    }
}

函数式接口可以lambda表达式实现其抽象方法，如上面的方法可用lambda表达式表示

GreetingService greetingService =  msg->System.out.println(msg);
greetingService.sayMessage("hello!");

三、Java8提供的常用函数式接口

1、Consumer(没有返回值)

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);
    
    // 为我们提供了一个链式的调用
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}
// 链式调用示例
Consumer<Integer> calculate = x->System.out.println(x*2);
Consumer<Integer> calculate2 = x->System.out.println(x*3);
calculate.andThen(calculate2).accept(2);

如果查看List集合的相关源码，可以在顶级接口Iterable中看到它的身影。

 default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
// 使用
 Arrays.stream(new int[5]).forEach(()->{});

2、Function

上面的Consumer抽象函数是没有返回值的，而Function与Consumer最大的区别是该接口的抽象函数式有返回值。

@FunctionalInterface
public interface Function<T, R> {

    // 接收一个泛型，返回一个泛型
    R apply(T t);

    // 链式处理，将上一次处理的结果作为下一次处理的参数
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    // 如compose相反，将调用者的结果作为参数处理的参数
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }


    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

3、Predicate

跟 Function很像，不过Predicate返回值是固定的boolean。

@FunctionalInterface
public interface Predicate<T> {

    // 接收一个泛型参数，返回boolean
    boolean test(T t);


    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }


    default Predicate<T> negate() {
        return (t) -> !test(t);
    }


    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

  
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}