源码
点击查看
@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);
/**
* Returns a composed function that first applies the {@code before}
* function to its input, and then applies this function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
*
* @param <V> the type of input to the {@code before} function, and to the
* composed function
* @param before the function to apply before this function is applied
* @return a composed function that first applies the {@code before}
* function and then applies this function
* @throws NullPointerException if before is null
*
* @see #andThen(Function)
*/
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
/**
* Returns a composed function that first applies this function to
* its input, and then applies the {@code after} function to the result.
* If evaluation of either function throws an exception, it is relayed to
* the caller of the composed function.
*
* @param <V> the type of output of the {@code after} function, and of the
* composed function
* @param after the function to apply after this function is applied
* @return a composed function that first applies this function and then
* applies the {@code after} function
* @throws NullPointerException if after is null
*
* @see #compose(Function)
*/
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
/**
* Returns a function that always returns its input argument.
*
* @param <T> the type of the input and output objects to the function
* @return a function that always returns its input argument
*/
static <T> Function<T, T> identity() {
return t -> t;
}
}
说明：
apply：接收一个参数，计算后，返回一个结果；
compose：先执行传入的函数，在执行自己的函数；
andThen：先执行自己的函数，在执行传入的函数；
示例
@Test
public void test3() {
Function<Integer, Integer> function1 = param -> param + 10;
Function<Integer, Integer> function2 = param -> param * 10;
// 3 + 10 ；执行 function1
System.out.println(function1.apply(3));
// ( 3 * 10 ) + 10 ；先执行 function2，再执行 function1
System.out.println(function1.compose(function2).apply(3));
// ( 3 + 10 ) * 10 ；先执行 function1，再执行 function2
System.out.println(function1.andThen(function2).apply(3));
}
输出结果：
13
40
130