Java8之Function函数、BiFunction函数详解

这篇具有很好参考价值的文章主要介绍了Java8之Function函数、BiFunction函数详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

众所周知,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的参数只会被根函数使用一次,之后的函数使用的是前一个函数的结果做为参数。

了解了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模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • java8 新特性

    1、lambda表达式 Lambda 是一个 匿名函数,我们可以把 Lambda 表达式理解为是 一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。 (1)语法 Lambda 表达式:在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “-” , 该操作

    2024年02月09日
    浏览(43)
  • JAVA8~17新特性

    目录 一、前言 二、JAVA8 Lambda表达式 Stream API 创建方式 中间操作 终止操作 Optional类 三、JAVA9 模块机制 JShell交互式编程   接口 新增集合工厂方法 四、JAVA10 局部变量类型判断 五、JAVA11 Lambda表达式补充 String方法的补充 全新的HttpClient 使用 六、JAVA12-16 新的switch语法 文本块 新

    2024年02月15日
    浏览(42)
  • Java8常用新特性

    目录 简介 1.默认方法 2..Lambda表达式 3.Stream API 4.方法引用 5.Optional类 Java 8是Java编程语言的一个重要版本,引入了许多令人兴奋和强大的新特性。这些特性使得Java程序更加现代化、灵活和高效。让我们一起来探索一些Java 8的常用新特性吧! 首先,Java 8引入了函数式编程的概念

    2024年01月22日
    浏览(38)
  • Java8新特性-流式操作

    在Java8中提供了新特性—流式操作,通过流式操作可以帮助我们对数据更快速的进行一些过滤、排序、去重、最大、最小等等操作并且内置了并行流将流划分成多个线程进行并行执行,提供更高效、快速的执行能力。接下来我们一起看看Java8为我们新增了哪些便捷呢? 目录 什

    2024年02月02日
    浏览(44)
  • Java8新特性—方法引用

    前言 Java 8引入了方法引用(method reference)作为一种语言特性,它可以简化代码,使得代码更加易读和易于维护。方法引用可以被视为Lambda表达式的简写形式,可以用来替代Lambda表达式中只调用一个已有方法的情况。总的来说该特性使得Java代码更加简洁和灵活。 使用场景 J

    2024年02月03日
    浏览(38)
  • Java8新特性整理记录

    方法一:  方法二:   例子:

    2024年02月11日
    浏览(42)
  • Java8的新特性以及使用

    1.   通 过 1 0 个示 例 来 初 步认 识 J a v a 8 中 的 l a m bd a 表达 式   我个 人 对 J a v a   8 发 布 非 常 激动 , 尤 其 是 l a m b d a 表 达式 和 流 AP I 。 越 来 越 多 的 了解 它 们 , 我 能 写 出 更 干 净 的代 码 。 虽然 一 开 始 并 不 是 这 样 。 第一 次 看 到 用 la m b d a 表

    2024年02月07日
    浏览(49)
  • Java8新特性lambda学习

    Lambda是一个 匿名函数 ,我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。 本质: 作为 函数式接口 的实例, 没有接口就没意义了. 这两

    2024年02月05日
    浏览(45)
  • 【Java8新特性--->异步处理】CompletableFuture

    一、引入 假设一个商品详情页需要以下操作: 查询展示商品的基本信息耗时:0.5s 查询展示商品的销售信息耗时:0.7s 查询展示商品的图片信息耗时:1s 查询展示商品销售属性耗时:0.3s 查询展示商品规格属性耗时:1.5s 查询展示商品详情信息耗时:1s 即使每个查询时间耗时不

    2024年02月06日
    浏览(43)
  • Java8新特性-Lambda表达式

    Lambda表达式 Lambda是一个匿名函数, 可以把lambda表达式理解为是一段可以传递的代码,(将代码像数据一样传递) 变化 需求: 求 薪资高于5000的员工信息 Lambda基本语法 在 java8 中引入了一个新的操作符 \\\"-\\\" , 箭头操作符, 箭头操作符 将Lambda表达式拆分为两部分: 左侧: Lambda表达式的参

    2024年02月01日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包