JDK8学习总结第一篇：常见函数式接口

jdk8在java.util.function的包新增40余个函数式接口，本篇将对其中重要的的接口进行详细介绍。

Function<T, R>

接受一个参数，产生一个结果。(Represents a function that accepts one argument and produces a result.)

• R apply(T t);
• default <V> Function<V, R> compose(Function<? super V, ? extend T> before){...}
• default <V> Function<T, V> andThen(Function<? super R, ? extend V> after){...}
• static <T> Function<T, T> identity()

apply详解

本方法在调用时需要实现。

compose详解

传递一个function，先执行传递的function，再执行接口的apply。如果在调用时发生异常，将异常信息转发给调用者。

andThen详解

传递一个function，先执行接口的apply，再执行传递的function。如果在调用时发生异常，将异常信息转发给调用者。

identity详解

返回输入参数的函数。

public class TestFunction1 {

    public static void main(String[] args) {
        Function<Integer, Integer> function = (x) -> x += 2;
        System.out.println(function.apply(2));

        // compose
        Function<Integer, Integer> function1 = (x) -> x * x;
        // 11
        System.out.println(function.compose(function1).apply(3));

        // andThen 25
        System.out.println(function.andThen(function1).apply(3));

        // identity
        List<String> list = Arrays.asList("1", "233", "1");
        Map<String, Integer> collect = list.stream()
            .collect(Collectors.toMap(Function.identity(), String::length, (o1, o2) -> o2));
        for (Map.Entry<String, Integer> entry : collect.entrySet()) {
            System.out.println(entry.getKey() + "---" + entry.getValue());
        }
    }
}

BiFunction<T, U, R>

接受两个参数，返回一个结果。(Represents a function taht accepts two arguments and produces a result.)

• R apply(T t, U u);
• default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after)

apply详解

本方法是接口需要实现。

andThen详解

先执行自己的apply方法，然后执行传入的Function。因为执行自己的apply只返回一个参数，所以组合只能是和Function，因为，Function接受一个值，返回一个值。

public class TestBiFunction {

    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (x, y) -> x + y;
        BiFunction<Integer, Integer, Integer> subtract = (x, y) -> x - y;
        BiFunction<Integer, Integer, Integer> multiply = (x, y) -> x + y;
        BiFunction<Integer, Integer, Integer> divide = (x, y) -> x + y;

        Function<Integer, Integer> square = x -> x * x;
        Integer result = add.andThen(square).apply(1, 2);
        System.out.println(result);
    }
}

Predicate<T>

传入一个值的谓词，布尔值函数。(Represents a predicate (boolean-valued function) of one argument.)

• boolean test(T t);
• default Predicate<T> and(Predicate<? super T> other)
• default Predicate<T> negate()
• default Predicate<T> or(Predicate<? super T> other)
• static <T> Predicate<T> isEqual(Object targetRef)

test详解

给定参数上计算此谓词。

and详解

两个谓词&&操作。抛出异常，不会被计算。

negate

取反操作。

or

两个谓词或操作。抛出异常，不会被计算。

isEqual

比较两个是否相等

public class TestPredicate1 {

    public static void main(String[] args) {
        Predicate<Integer> predicate1 = x -> x > 5;
        Predicate<Integer> predicate2 = x -> x < 10;
        System.out.println(predicate1.test(10));
        System.out.println(predicate1.and(predicate2).test(8));
        System.out.println(predicate1.negate().test(1));
        System.out.println(predicate1.or(predicate2).test(18));
        Predicate<String> predicate3 = Predicate.isEqual(null);
        System.out.println(predicate3.test(null));
    }
}