理解Function和BiFunction

Function

1. Function作为一个函数式接口，主要方法apply接受一个参数，返回一个值

1
2
3
4
5
6
7
8
9
10
11
@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);
}


这里需要注意的是定义的范型，这个接口中声明了2个类型，其中T为方法参数类型，R为方法返回类型

同时该接口包含了2个default方法，用来对函数进行组合

1
2
3
4
5
6
7
8
9
10
11
<!--这个方法用来组合一个函数，被组合的函数先执行，-->
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}

<!--同样这也用来组合一个函数，区别在于被组合的函数后执行-->
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}

2. 使用

上面的例子中声明了2个函数f1和f2，分别使用不同的组合方法。

1
2
3
4
5
6
7
8
9
10

@Test
public void test() {
    Function<Integer, Integer> f1 = x -> {return x * x;};
    Function<Integer, Integer> f2 = x -> {return x + x;};

    //（3+3）*（3+3）= 36
    System.out.println(f1.compose(f2).apply(3));
    //（3*3）+（3*3）=18
    System.out.println(f1.andThen(f2).apply(3));
}

BiFunction

1. BiFunction也是一个函数式接口，和Function接口不同的是，它在接口中声明了3个泛型，其中前两个作为方法参数类型，最后一个作为返回类型

   1 2 3 4 5 6 7 8 9 10 11 12

   @FunctionalInterface public interface BiFunction<T, U, R> { /** * Applies this function to the given arguments. * * @param t the first function argument * @param u the second function argument * @return the function result */ R apply(T t, U u); }

   同时在BiFunction接口中定义了一个default方法andThen,用来与Function函数进行组合

2. 使用

   定义一个函数实现，然后对BiFunction和Function进行组合

   1 2 3 4 5 6 7 8

   @Test public void test() { BiFunction<String, String, String> f1 = (x,y) -> "world " + x + y; Function<String, String> f2 = (x) -> "hello " + x; System.out.println(f1.apply("zhang", "san")); System.out.println(f1.andThen(f2).apply("li", "si")); }

其它函数式接口

在理解了Function接口之后再去理解这些函数接口道理都是一样的，主要区别在于接口声明中范型的的用法

Supplier

这个接口用来生产一个T类型的对象

1
2
3
4
5
6
7
8
9
10

@FunctionalInterface
public interface Supplier<T> {

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

Consumer

这个接口用来消费一个对象，无返回

1
2
3
4
5
6
7
8
9
10

@FunctionalInterface
public interface Consumer<T> {

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

Predicate

这个接口用来测试一个对象,返回值为一个boolean类型

1
2
3
4
5
6
7
8
9
10
11
12

@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);
}