众所周知,Java8提供了一下非常重要的函数式接口。今天我们就来讲讲其中一个函数式接口-----Function接口。
下面的代码就是Function接口的全部代码。接下来我们逐个分析一下。
@FunctionalInterface
public interface Function<T, R>
@FunctionalInterface 表明该接口是一个函数式接口
<T, R> T 代表参数,R 代表返回值。
第一个方法------R apply(T t)
示例代码:
public class FunctionTest {
public static void main(String[] args) {
FunctionTest functionTest = new FunctionTest();
System.out.println(functionTest.compute(1, value -> 2 * value));
}
public int compute(int a, Function<Integer, Integer> function) {
int result = function.apply(a);
return result;
}
}
上述代码展示的就是Function接口中apply方法的使用,其中通过 functionTest.compute方法将两个参数传过去,在compute方法中,function使用参数进行运算。
第二个方法 ------- compose
这个方法是一个默认方法。为了方便在接口中实现具体逻辑,而添加的关键字。
我们可以看到compose方法有一个输入参数为Function类型的值,并且也会返回一个Function类型的值,重点我们看最后一句就会发现,它是先调用参数的apply 方法 再调用调用者的apply 方法
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
通过上面的分析,可以得出结果----12,即对参数先执行 value * value,在执行 value * 3。
System.out.println(functionTest2.compute(2, value -> value * 3, value -> value * value));
public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
return function1.compose(function2).apply(a);
}
第三个方法 ------ andThen
大家是不是觉得这个方法和上面的compose方法差不多,唯一的差别就是最后一句。该方法执行的顺序就是先执行调用者的apply方法,在执行参数的apply方法。(与compose方法相反)
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
示例代码
经过上面的分析,我们很容易得出结果,值为36。
System.out.println(functionTest2.compute(2, value -> value * 3, value -> value * value));
public int compute2(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
return function1.andThen(function2).apply(a);
}
第四个方法 ------ identity
static <T> Function<T, T> identity() {
return t -> t;
}
该行代码因为实现了Function中唯一的抽象方法,所以通过下面这行代码实例化出了一个 “接口” 对象,同样也会输出helloworld
Function<String, String> fun1 = Function.identity();
String str1 = fun1.apply("helloWorld");
System.out.println(str1);
看完了Function,相信大家在学习Java8的时候,都看到了还有一个叫BiFunction的类,下面我们来分析一下BiFunction
什么是BiFunction
@FunctionalInterface
public interface BiFunction<T, U, R>
它也是一个函数式接口,它是Function 的 另一种形式,它接收两个参数(T,U),返回一个参数(R)。那么接下来我们看看这个接口里面有哪些方法吧。
第一个方法 ------ apply
R apply(T t, U u);
示例代码:
System.out.println(functionTest2.compute4(2, 3, (value1, value2) -> value1 + value2));
public int compute4(int a, int b, BiFunction<Integer, Integer, Integer> biFunction) {
return biFunction.apply(a, b);
}
上述代码,使用的就是apply方法,我们发现,其实它跟Function里面的apply其实一样,也就是多了一个参数而已。接下来,我们看第二个方法。
第二个方法 ----- andThen
源码:
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));
}
我们发现,andThen方法里面的参数是Function类型的,那为什么不能是BiFunction类型的呢。
andThen是先执行调用者的apply,也就是说他先调用BiFunction的apply方法,再去调用参数的apply方法;其中根据Java的规范,一个方法,只能有一个返回值。所以当执行参数的apply方法的时候,只能有一个参数,所以andThen方法里面的参数必须是Function类型的。
那么大家可能会问了,为什么BiFunction里面没有compose方法。
根据Function接口里面的compose方法,我们可以分析出,它是先执行参数的apply方法,在执行调用者的apply方法。
假如BiFunction里面有compose,又因为BiFunction接受两个参数,那么通过上面的分析,可以得出,它的compose方法的参数必定是BiFunction类型的,但是下一步执行调用者的apply方法的时候,因为只有一个参数,所以是无法满足的。所以BiFunction里面没有compose方法。
源码:
public interface Function<T, R> {
/**
* 将此函数应用于给定参数
* 真正执行函数接口的方法
*/
R apply(T t);
/**
* 函数链,before执行的结果做根函数为参数
*/
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
/**
* 函数链,根函数执行结果做为after的参数
*/
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
/**
* 返回一个参数做为返回值的函数
*/
static <T> Function<T, T> identity() {
return t -> t;
}
}
看注释有些绕,还是看例子
//例1
public class FunctionDemo {
public static void main(String[] args) {
Function<Integer,Integer> root = (v) -> {
System.out.println("root apply");
return v + 1;// 12
};
Function<Integer,Integer> before = (v) -> {
System.out.println("before apply");
return v + 1;// 先得结果11,再传给root
};
System.out.println(root.compose(before).apply(10));
// before apply
// root apply
// 12
}
}
//例2
public class FunctionDemo {
public static void main(String[] args) {
Function<Integer,Integer> root = (v) -> {
System.out.println("root apply");
return v + 1;// 先得结果11,再传给after
};
Function<Integer,Integer> after = (v) -> {
System.out.println("after apply");
return v + 1;// 12
};
System.out.println(root.andThen(after).apply(10));
// root apply
// after apply
// 12
}
}
例1和例2虽然参数一样,结果一样,但是相对与根函数root执行的顺序一个在前,一个在后。
Function与Consumer接口都有andThen方法,两者的区别是对参数的使用方式不同。每Consumer使用的是同一个原始参数,Function的参数只会被根函数使用一次,之后的函数使用的是前一个函数的结果做为参数。文章来源:https://www.toymoban.com/news/detail-673479.html
了解了Function,其他的也就一目了然了:文章来源地址https://www.toymoban.com/news/detail-673479.html
BiFunction<T,U,R>:代表了一个接受两个输入参数的方法,并且返回一个结果
DoubleFunction<R>:代表接受一个double值参数的方法,并且返回结果
DoubleToIntFunction:接受一个double类型输入,返回一个int类型结果。
DoubleToLongFunction:接受一个double类型输入,返回一个long类型结果
IntFunction<R>:接受一个int类型输入参数,返回一个结果 。
IntToDoubleFunction:接受一个int类型输入,返回一个double类型结果 。
IntToLongFunction:接受一个int类型输入,返回一个long类型结果。
LongFunction<R>: 接受一个long类型输入参数,返回一个结果。
LongToDoubleFunction: 接受一个long类型输入,返回一个double类型结果。
LongToIntFunction:接受一个long类型输入,返回一个int类型结果。
ToDoubleBiFunction<T,U>:接受两个输入参数,返回一个double类型结果
ToDoubleFunction<T>:接受一个输入参数,返回一个double类型结果
ToIntBiFunction<T,U>:接受两个输入参数,返回一个int类型结果。
ToIntFunction<T>:接受一个输入参数,返回一个int类型结果。
ToLongBiFunction<T,U>:接受两个输入参数,返回一个long类型结果。
ToLongFunction<T>:接受一个输入参数,返回一个long类型结果。
到了这里,关于Java8之Function函数、BiFunction函数详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!