函数式接口

一、函数式接口的定义

  函数式接口：函数式接口中有且仅有一个抽象方法，这个抽象方法的意义在于表达某种行为。

  以下情况是满足函数式接口定义的：
  1. 接口中可以有多个默认实现，但是默认实现需要用default关键字显示标注。

@FunctionalInterface
//此注解用于显式表示一个接口是否满足函数式接口的定义，如果不满足定义会标红
public interface MyInterface {
    String getName();
    
    //这是默认实现的方法，并不违反函数接口的规则。
    default int getAge(){
        return 1;
    }
}

  2. 接口可以包含过个静态方法。

@FunctionalInterface
public interface MyInterface {
    String getName();

    //这是静态的方法，并不违反函数接口的规则。
    static int getAge() {
        return 1;
    }
}

  3. 接口可以包含和Object的public一样方法签名的方法，但是此方法需要是抽象的。

@FunctionalInterface
public interface MyInterface {
    String getName();

    //该方法的方法签名与Object的相同
    //并且是抽象的，因为实现此接口的实现类，必然会提供方法的实现。
    int hashCode();
}

二、函数式接口的表示

  函数式接口的实例有三种方式创建：Lambda表达式、方法引用和构造方法引用。因为函数式接口只有一个抽象方法，所以Lambda表达式实际代表的行为就是接口中的抽象方法，也从侧面说明了Lambda表达式不能脱离函数式接口的语境。

  函数式接口与Lambda表达式有着天然的联系，Lambda表达式的基本结构是

(Type1 arg1,Type2,arg2,...) -> {body}

  1. 如果参数可以通过类型推导出来，那么参数类型可以不写。（可以先不写试试）

  2. 如果参数只有一个，可以将括号省略。

  3. body如果只有一行代码，可以省略花括号。注意的是一行代码的表示有表达式和语句之分，需要配合return、分号、花括号的情况。
  4. 为了便于理解和说明，这里将Lambda表达式的按着其参数和返回值类型进行描述。

  (int a,int b)->a+b 的类型为（int，int）->int

  (int a,int b)->println(a+b) 的类型为（int，int）->Unit（不返回值）

三、JDK8中的常见的函数式接口

  Consumer：接受一个参数，不返回结果

/**
 * 这个函数式接口代表一种操作行为：无返回结果的单一参数操作
 * 接口中的抽象方法，就是操作
 * 仍包含一个默认方法
 */
@FunctionalInterface
public interface Consumer<T> {

    /**
     * 对给定的参数进行操作
     */
    void accept(T t);

    /**
     * 返回一个组合的Consumer。对t参数执行完给定的行为后，再去执行after行为。
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

  以集合遍历为例

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);

        //forEach函数参数类型是Consumer，对集合的每个元素执行accept行为（第一处）
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                //此处的行为就是对元素进行打印，
                System.out.println(integer);
            }
        });

        //Lambda表达式 就是描述的接口的抽象方法
        //本例中，接口的抽象方法 （接受一个参数，执行一个无返回结果的操作）
        //也就是（T t）->Unit,式子中的item可以命名为任意名字
        list.forEach(item -> System.out.println());
    }

}

//第一处的源码如下
//调用的是Iterable接口的默认方法forEach
default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        //遍历集合的每一个元素
        for (T t : this) {
            //调用接口的accept行为方法，参数是集合的元素
            action.accept(t);
        }
    }
//以上的源码就说明了  Consumer代表一种抽象的行为，集合的元素去参与这个行为，开发者需定义出具体行为。

  Function接口：接受一个参数，返回一个结果

/**
 * 接受一个t参数返回一个R类型的结果，T与R可以相同也可以不同
 */
@FunctionalInterface
public interface Function<T, R> {

    /**
     * t参数去执行给定的行为
     */
    R apply(T t);

    /**
     * 返回一个符合函数，在本实例行为执行前，先去执行before的行为，将before的结果作为本实例行为的输入
     * 因此，before的结果类型一定要是T类型的子类或本身。
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        //先执行before，再执行本实例的行为
        return (V v) -> apply(before.apply(v));
    }

    /**
     * 返回一个符合函数，在本实例行为执行后，紧接着去执行after的行为，将本实例的结果作为after行为的输入
     * 因此，after的输入一定是本实例结果的父类型或本身
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        //先执行本实例，再执行after
        return (T t) -> after.apply(apply(t));
    }

    /**
     * 返回一个参数无操作的行为
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

  以字符串取小写为例

public class FunctionTest {
    public static void main(String[] args) {
        FunctionTest functionTest = new FunctionTest();
        
        //匿名函数 （第一处）
        functionTest.operation("Hello world", new Function<String, String>() {
            @Override
            public String apply(String str) {
                return str.toLowerCase();
            }
        });

        //表达式
        functionTest.operation("Hello world", item -> item.toLowerCase());

        //Lambda表达式声明函数式接口的实例
        Function<String, String> function = item -> item.toLowerCase();
        functionTest.operation("Hello world",function);

        //语句
        functionTest.operation("Hello world", item -> {
            return item.toLowerCase();
        });
        
        //以上几种方式 都是对Function的实践。定义一种行为：对字符串进行小写并返回
        //输入类型和输出类型都是字符串。
        //开发者自己定义操作的行为，调用的方法都是operation。
    }

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

  以第一处为例分析其执行流程
  ①调用operation方法，参数是"Hello World"、匿名类。
  ②调用参数function的apply方法，实际调用的是传入的匿名类的apply方法。
  ③apply方法的参数是传入的"Hello World",执行取小写操作。
  综上：开发者需要的是在方法的调用处，定义出需执行的行为，传递的是行为。定义行为的方式有匿名类，Lambda表达式，方法引用等，Lambda表达式更加简洁。

  BiFunction：接受两个参数，返回一个结果

/**
 * 是Function思想的特殊化，接受两个参数，返回一个R类型结果
 */
@FunctionalInterface
public interface BiFunction<T, U, R> {

    /**
     * 对t和u参数执行给定的行为
     */
    R apply(T t, U u);

    /**
     * 返回一个复合的函数，在执行完本实例行为后，将本实例的结果作为after行为的输入，执行after行为。
     */
    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        //先执行本实例行为，在执行after行为
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

  以数字的四则运算操作为例

public class FunctionTest2 {
    public static void main(String[] args) {
        FunctionTest2 test = new FunctionTest2();
        //Lambda表达式创建出BiFunction实例
        //开发者需自己定义出 执行的行为，并传递给compute函数
        //compute函数执行具体的行为
        test.compute(2, 3, (a, b) -> a + b);
        test.compute(2, 3, (a, b) -> a - b);
        test.compute(2, 3, (a, b) -> a * b);
        test.compute(2, 3, (a, b) -> a / b);

        //先执行两个数字相乘，将结果执行平方（第一处）
        test.compute1(2, 3, (a, b) -> a * b, a -> a * a);
    }


    public int compute(int a, int b, BiFunction<Integer, Integer, Integer> function) {
        return function.apply(a, b);
    }

    public int compute1(int a, int b, BiFunction<Integer, Integer, Integer> biFunction, Function<Integer, Integer> function) {
        return biFunction.andThen(function).apply(a, b);
    }
}

  第一处的执行流程
  ①将Lambda表达式构建的接口实例传入compute1方法。
  ②调用BiFunction（数字的乘积）的andTen方法，参数是 function（数字的平方）
  ③调用BiFunction（数字的乘积）的apply方法，计算出实际的结果
  ④调用function（数字的平方）的apply方法，参数是上一步的结果
  ⑤返回结果

  Predicate：判断参数是否满足 断言

/**
 * 判断参数是否满足 断言（也就是布尔值）
 */
@FunctionalInterface
public interface Predicate<T> {

    /**
     * 对给定的参数t执行测试行为
     */
    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);
    }

    /**
     *测试两个实例是否相同（equals相等）
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

  以字符串判断equals为例

public class PredicateTest {
    public static void main(String[] args) {

        PredicateTest predicateTest = new PredicateTest();
        //第一处
        predicateTest.predicateString("Hello", item -> item.equals("test"));
        


        //第二处
        Predicate<String> predicate = Predicate.isEqual("test");
        predicate.test("Hello");
        
        //以上两个例子并无不同，Predicate的静态isEqual方法只是帮我们写了断言条件
        //第一处的流程分析
        //①调用predicateString方法，参数是“Hello”和Lambda表达式生成的接口实例
        //②调用接口实例的test方法，就是item -> item.equals("test")
        //  item就是“Hello”
        //③返回断言结果false

        //第二处的流程分析
        //①调用静态方法isEqual("test")，生成接口实例
        //②调用test方法，参数是“Hello”
        //③test的实现是isEqual，返回结果false
    }

    public boolean predicateString(String str, Predicate<String> predicate) {
        return predicate.test(str);
    }
}

  Supplier：返回一个结果即可，无参数

/**
 *返回一个结果
 */
@FunctionalInterface
public interface Supplier<T> {

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

四、总结以上接口

  Consumer<T>
  void accept(T t);
  接受一个参数，不返回结果

  Function<T,R>
  R apply(T t);
  接受一个类型的参数，返回一个结果
  可以通过默认的compose和andThen方法复合函数

  BiFunction<T, U, R>
  R apply(T t, U u);
  接受两个类型的参数，返回一个结果

  Predicate<T>
  boolean test(T t);
  接受一个参数，返回一个Boolean值

  Supplier<T>
  T get()
  不接受参数返回一个结果

五、小结

函数式的参数代表的是一种行为，开发者传递的是某种操作