Java8新特性Function和BiFunction

Function

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

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

首先我们来写一个计算数字的方法

public int compute(int a, Function<Integer, Integer> function) {
    int result = function.apply(a);
    return result;
}

然后我们调用这个方法

test.compute(5, value -> value * value) //25 计算平方
test.compute(5, value -> value + value) //10 求和
test.compute(5, value -> value - 2) //3

可以看到我们定义一个方法就可以实现多种功能，这就是前面说过的Lambda表达式传递的是一种行为，我们把想要做的事在调用的时候，以一种行为的方式传递进来，程序读起来也更加直观

Function compose方法

compose方法是一个默认方法，这个方法接收一个function作为参数，将参数function执行的结果作为参数给调用的function，以此来实现两个function组合的功能。

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

下面我们来举例看一下：

public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
    return function1.compose(function2).apply(a);
}

调用这个方法：

test.compute(2, value -> value * 3, value -> value * value)

大家可以猜一下上面的结果是多少？

我们来分析一下：

function1.compose(function2).apply(a);

compose方法内部代码是：

return (V v) -> apply(before.apply(v));

返回的是一个Function，输入一个参数，返回一个参数值，这个Function 在调用apply时首先执行的是before.apply(v)，before在这里就是value -> value * value，也就是 2*2，将得到的结果4，作为参数传递给function1，在这里就是value -> value * 3，所以结果是：12

Function andThen

了解了compose方法，我们再来看andThen方法就好理解了，听名字就是“接下来”，andThen方法也是接收一个function作为参数，与compse不同的是，先执行本身的apply方法，将执行的结果作为参数给参数中的function。

public interface Function<T, R> {
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
}

下面我们来举例看一下：

public int compute2(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
    return function1.andThen(function2).apply(a);
}

调用这个方法：

test.compute2(2, value -> value * 3, value -> value * value)

这次结果是多少呢？我想大家应该很容易就知道了，首先执行的是value -> value * 3结果是6，然后执行的是value * value最终结果是36

BiFunction

了解了Function以后，有的小伙伴可能会问了，Function只能接收一个参数，如果我要传递两个参数呢，这一点Java8也替我们考虑到了，就是我们截下来要讲到的 BiFunction，首先还是直接上源码：

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);

    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

可以看到BiFunction的apply方法，接收两个参数，返回一个值，来看一个例子

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

我们定义了一个方法，可以用来计算两个数的很多运算

test.compute3(2, 3, (v1, v2) -> v1 + v2) //5
test.compute3(2, 3, (v1, v2) -> v1 - v2) //-1
test.compute3(2, 3, (v1, v2) -> v1 * v2) //6

这个还是蛮简单的，我们再来看一下，BiFunction中有一个andThen方法，参数是一个Function，方法主要是将BiFunction返回的结果作为Function的参数，得出一个结果，举例：

public int compute4(int a, int b, BiFunction<Integer, Integer, Integer> biFunction, Function<Integer, Integer> function) {
    return biFunction.andThen(function).apply(a, b);
}
test.compute4(2, 3, (v1, v2) -> v1 + v2, v1 -> v1 * v1)

首先执行(v1, v2) -> v1 + v2，然后执行v1 -> v1 * v1

有的同学可能会问为什么BiFunction没有compose方法呢，大家仔细想一想，如果有compose方法的话，那就是先执行Function的apply方法，但是执行完毕后只返回一个参数，而BiFunction需要两个参数，所以肯定是不行的。

代码案例

public class FunctionTest {

    public static void main(String[] args) {
        FunctionTest test = new FunctionTest();
        System.out.println(test.compute(1, a -> a + 1));

        // 普通定义
        Function<Integer, Integer> function = new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer o) {
                return o * o;
            }
        };
        Function<Integer, String> function1 = function.andThen(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return "result is " + integer;
            }
        });

        String apply = function1.apply(2);
        System.out.println(apply);
        // 用lambda的方式实现
        Function<Integer, Integer> lambdaFunc = o -> o * o;
        Function<Integer, String> function2 = lambdaFunc.andThen(o -> "result is " + o);
        String apply1 = function2.apply(2);
        System.out.println(apply1);
    }

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

2
result is 4
result is 4

public class BiFunctionTest {

    public static void main(String[] args) {
        Person zhangsan = new Person(20, "zhangsan");
        Person lisi = new Person(30, "lisi");
        Person wangwu = new Person(40, "wangwu");

        List<Person> personList = new ArrayList<>();
        personList.add(zhangsan);
        personList.add(lisi);
        personList.add(wangwu);

        BiFunctionTest test = new BiFunctionTest();
        List<Person> personByName = test.getPersonByName("zhangsan", personList);
        List<Person> personByAge = test.getPersonByAge(20, personList);
        System.out.println(personByName);
        System.out.println(personByAge);

        List<Person> personByAge2 = test.getPersonByAge2(20, personList, (age, list) -> list.stream()
                .filter(p -> p.getAge() > age).collect(Collectors.toList()));
        System.out.println(personByAge2);
    }

    public List<Person> getPersonByName(String name, List<Person> personList) {
        return personList.stream().filter(person -> person.getName().equals(name)).collect(Collectors.toList());
    }

    public List<Person> getPersonByAge(int age, List<Person> personList) {
        BiFunction<Integer, List<Person>, List<Person>> biFunction
                = (ageOfPerson, persons) -> persons.stream()
                .filter(person -> person.getAge() > 20)
                .collect(Collectors.toList());
        return biFunction.apply(age, personList);
    }

    // 更加灵活的方式 让调用者实现过滤的条件 是大于还是小于
    public List<Person> getPersonByAge2(int age, List<Person> personList, BiFunction<Integer, List<Person>, List<Person>> biFunction) {
        return biFunction.apply(age, personList);
    }
}

[Person(age=20, name=zhangsan)]
[Person(age=30, name=lisi), Person(age=40, name=wangwu)]
[Person(age=30, name=lisi), Person(age=40, name=wangwu)]