如何使用lambda表达式提升开发效率?

Java8 的一个大亮点是引入 Lambda 表达式,使用它设计的代码会更加简洁。当开发者在编写 Lambda 表达式时,也会随之被编译成一个函数式接口。

OSCHINA 本期高手问答 (8 月 23 日 - 8 月 29 日) 我们请来了嘉宾 阿超老师 来和大家一起探讨关于 Lambda 和 Stream 的问题,将以【如何使用 lambda 表达式提升开发效率】为切入点展开讨论。

可讨论的问题包括但不限于:

lambda 表达式的应用场景

Stream 的应用场景

Lambda/Stream 的进一步封装

除了上述三个范围,你也可以将讨论的内容外延到函数式编程的整个领域(不限于编程语言),包括各大开源项目中对其的封装、应用等等,还可以专注于开源的 orm 框架 Mybatis-Plus 的源码、实践等细节。

嘉宾介绍

阿超,00 后全栈开发,dromara 组织成员、hutool 团队成员、mybatis-plus 团队成员、stream-query 项目作者,参与贡献的开源项目包括不限于 apache-shenyu、apache-streampark 等。

为了鼓励踊跃提问,问答结束后我们会从提问者中抽取 5 名幸运会员,赠予 开源项目 stream-query 的开源周边 T 恤,由阿超亲自设计!

Lambda 表达式

简单来说:就是把我们的函数 (方法) 作为参数传递、调用等

例子:自定义函数式接口(用 jdk 自带的函数式接口也可以)

import java.io.Serializable;/** * 可序列化的Functional * * @author VampireAchao */@FunctionalInterfacepublic interfaceFunc extendsSerializable{    /**     * 调用     *     * @param t 参数     * @return 返回值     */    R apply(T t);}

我们定义一个类可以去实现该接口

/** * 可序列化的函数式接口实现类 * * @author VampireAchao */public classFuncImplimplementsFunc {    /**     * 调用     *     * @param o 参数     * @return 返回值     */    @Override    public String apply(Object o) {        return o.toString();    }}

到此为止,都非常的简单 这里就有个问题:假设我有很多的地方需要不同的类去实现 Func,我就得每次都去写这么一个类,然后实现该接口并重写方法 这样很麻烦!因此我们使用匿名内部类

        Func func = new Func() {            /**             * 调用             *             * @param s 参数             * @return 返回值             */            @Override            public Integer apply(String s) {                return s.hashCode();            }        };

我们可以看到,使用了匿名内部类后不用每次去新建这个类了,只需要在调用的地方,new 一下接口,创建一个匿名内部类即可 但这样还有个问题,我们每次都要写这么一大几行代码,特别麻烦 由此而生,我们有了 lambda 这种简写的形式 https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#syntax

        Func func1 = (String s) -> {            return s.toUpperCase();        };

如果只有一行,我们可以省略掉中括号以及 return

        Func func2 = (String s) -> s.toUpperCase();

我们可以省略掉后边的参数类型

        Func func3 = s -> s.toUpperCase();

如果我们满足特定的形式,我们还可以使用方法引用(双冒号)的形式缩写

        Func func4 = String::toUpperCase;

这里除了我们的参数->返回值写法:s->s.toUpperCase(),还有很多种 例如无参数带返回值写法 ()->"yes"、无参无返回值写法 ()->{} 等等 而方法引用这种写法有如下几种: https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

package org.dromara.streamquery;import java.util.function.Function;import java.util.function.IntFunction;import java.util.function.Supplier;/** * 语法糖——方法引用 * * @author VampireAchao */public class MethodReferences {    public static Object staticSupplier() {        return "whatever";    }    public Object instanceSupplier() {        return "whatever";    }    public Object anonymousInstanceFunction() {        return "whatever";    }    public static void main(String[] args) {        // 引用构造函数        Supplier conSup = () -> new MethodReferences();        conSup = MethodReferences::new;        // 数组构造函数引用        IntFunction intFunction = value -> new int[value];        // intFunc == new int[20];        int[] intFuncResult = intFunction.apply(20);        // 引用静态方法        Supplier statSup = () -> staticSupplier();        statSup = MethodReferences::staticSupplier;        Object statSupResult = statSup.get();        // 引用特定对象的实例方法        Supplier instSup = new MethodReferences()::instanceSupplier;        instSup = new MethodReferences()::instanceSupplier;        Object instSupResult = instSup.get();        // 引用特定类型的任意对象的实例方法        Function anonInstFunc = streamDemo -> streamDemo.anonymousInstanceFunction();        anonInstFunc = MethodReferences::anonymousInstanceFunction;    }}

顺便放几个常用的,jdk 自带的函数式接口写法

package org.dromara.streamquery;import java.math.BigDecimal;import java.util.function.*;/** * 常用的几个函数式接口写法 * * @author VampireAchao */class Usual {    public static Consumer consumer() {        // 有参数无返回值        return o -> {        };    }    public static Function function() {        // 有参数有返回值        return o -> o;    }    public static Predicate predicate() {        // 有参数,返回值为boolean        return o -> true;    }    public static Supplier supplier() {        // 无参数有返回值        return Object::new;    }    public static BiConsumer biConsumer() {        // 俩参数无返回值        return (q, o) -> {        };    }    public static BiFunction biFunction() {        // 俩参数,有返回值        return (q, o) -> new BigDecimal(q).add(BigDecimal.valueOf(o));    }    public static UnaryOperator unaryOperator() {        // 一个参数,返回值类型和参数一样        return q -> q;    }    public static BinaryOperator binaryOperator() {        // 俩参数和返回值类型保持一致        return (a, o) -> a;    }}

Stream

Java 8 API 添加了一个新的抽象称为流 Stream,可以让你以一种声明的方式处理数据。方法全是传入函数作为参数,来达到我们的目的。 https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

        // 声明式编程是告诉计算机需要计算“什么”而不是“如何”去计算        // 现在,我想要一个List,包含3个数字6        List sixSixSix =                // 我想要:                Stream                        // 数字6                        .generate(() -> 6)                        // 3个                        .limit(3)                        // 最后收集起来转为List                        .collect(Collectors.toList());        sixSixSix.forEach(System.out::print);

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

        // 就像sql里的排序、截取        // 我要把传入的list逆序,然后从第五个(元素下标为4)开始取值,取4条        abc = abc.stream()                // 排序(按照自然顺序的逆序)                .sorted(Comparator.reverseOrder())                // 从下标为4开始取值                .skip(4)                // 取4条                .limit(4)                // 最后收集起来转为List                .collect(Collectors.toList());        System.out.println("我要把传入的list逆序,然后从第五个(元素下标为4)开始取值,取4条");        abc.forEach(System.out::print);        System.out.println();

Stream API 可以极大提高 Java 程序员的生产力,让程序员写出高效率、干净、简洁的代码。

    /**     * 老办法实现一个list,存储3个6     *     * @return [6, 6, 6]     */    private static List oldSix() {        // 老办法        List sixSixSix = new ArrayList(3);        sixSixSix.add(6);        sixSixSix.add(6);        sixSixSix.add(6);        System.out.println("老办法实现一个list,存储3个6");        for (Integer integer : sixSixSix) {            System.out.print(integer);        }        System.out.println();        return sixSixSix;    }    /**     * 新方法实现一个list,存储3个6     *     * @return [6, 6, 6]     */    private static List newSix() {        List sixSixSix = Stream.generate(() -> 6).limit(3).collect(Collectors.toList());        System.out.println("新方法实现一个list,存储3个6");        sixSixSix.forEach(System.out::print);        System.out.println();        return sixSixSix;    }

这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。

        // 管道中传输,节点中处理        int pipe = abc.stream()                // 筛选                .filter(i -> i > 'G')                // 排序                .sorted(Comparator.reverseOrder())                .mapToInt(Object::hashCode)                // 聚合                .sum();        System.out.println("将26个字母组成的集合过滤出大于'G'的,逆序,再获取hashCode值,进行求和");        System.out.println(pipe);

元素流在管道中经过中间操作(intermediate operation)的处理,最后由最终操作 (terminal operation) 得到前面处理的结果。

        // 将26个大写字母Character集合转换为String然后转换为小写字符        List terminalOperation = abc.stream()                // 中间操作(intermediate operation)                .map(String::valueOf).map(String::toLowerCase)                // 最终操作(terminal operation)                .collect(Collectors.toList());        System.out.println("26个大写字母Character集合,转换成String然后转换为小写字符,收集起来");        terminalOperation.forEach(System.out::print);        System.out.println();

审核编辑:汤梓红

版权声明:
作者:网友投稿
链接:http://qiangcao.com/zs/1399.html
来源:轩哥技术分享
文章版权归作者所有,未经允许请勿转载。

THE END
分享
二维码
< <上一篇
下一篇>>