当前位置：首页 > 科技 > 软件

提高生产力！这10个Lambda表达式必须掌握，开发效率嘎嘎上升！

来源：责编：时间：2024-04-02 17:23:35 126观看

导读在Java8及更高版本中，Lambda表达式的引入极大地提升了编程的简洁性和效率。本文将围绕十个关键场景，展示Lambda如何助力提升开发效率，让代码更加精炼且易于理解。集合遍历传统的for-each循环对集合进行遍历虽然直观，但在

在Java8及更高版本中，Lambda表达式的引入极大地提升了编程的简洁性和效率。本文将围绕十个关键场景，展示Lambda如何助力提升开发效率，让代码更加精炼且易于理解。

集合遍历

传统的for-each循环对集合进行遍历虽然直观，但在处理大量数据时显得冗长。例如：

List<String> list = Arrays.asList("a", "b", "c");for (String s : list) {    System.out.println(s);}

使用Lambda表达式后，代码变得更加紧凑：

list.forEach(System.out::println);

集合排序

在以前我们对集合中的元素进行排序时，需要实现Comparable接口，或者使用Comparator比较器，在其中定义排序规则。

Collections.sort(list, new Comparator<String>() {    @Override    public int compare(String s1, String s2) {        return s1.length() - s2.length();    }});

使用Lambda可以进行简化：

List<String> sortedList = list.sort(Comparator.comparingInt(String::length));// 或者Collections.sort(list, (s1, s2) -> s1.length() - s2.length());// 或者Collections.sort(list, Comparator.comparingInt(String::length));

集合过滤

以往的过滤操作以往需要编写繁琐的条件判断。

List<String> filterList = new ArrayList<>();for (String s : list){    if (s.length() >= 4){        filterList.add(s);    }}

使用Lambda可以进行简化：

List<String> filterList = list.stream().filter(e -> e.length() >= 4).collect(Collectors.toList());

关于Stream的使用方法请参考：提高Java开发生产力，我选Stream,真香啊

映射操作

如以下操作，将一个集合变成另外一个集合

List<String> upperCaseList = new ArrayList<>();for (String str : words) {    upperCaseList.add(str.toUpperCase());}

而Lambda表达式可用于将集合中的元素直接转换成新的形式：

List<String> upperList = list.stream().map(e -> e.toUpperCase()).collect(Collectors.toList());        upperList = list.stream().map(String::toUpperCase).collect(Collectors.toList());        List<Integer> lengthList = list.stream().map(e -> e.length()).collect(Collectors.toList());        lengthList = list.stream().map(String::length).collect(Collectors.toList());

规约操作

规约操作，即对一个集合中的元素进行求和，求平均数等

int sum = 0;for (int num : numbers) {    sum += num;}

使用Lambda简化

int sum = numbers.stream().mapToInt(Integer::intValue).sum();int sum = numbers.stream().reduce(0, (n1, n2) -> n1 + n2);int sum = numbers.stream().reduce(0, Integr::sum);List<Person> peoples = new ArrayList<>();int ages = peoples.stream().mapToInt(Person::getAge).sum();

关于Stream的使用方法请参考：提高Java开发生产力，我选Stream,真香啊

分组操作

对一个集合基于特定规则对集合进行分组，即将List<Object>转换为Map<Object, List<Object>>

List<Person> personList = new ArrayList<>();Map<String, List<Person>> groupMap = new HashMap<>();for (Person person : personList) {    Integer age = person.getAge();    if (!groupMap.containsKey(age)) {        groupMap.put(age, new ArrayList<>());    }    groupMap.get(age).add(person);}

使用Lambda简化：

Map<String, List<Person>> groupMap = words.stream()    .collect(Collectors.groupingBy(Person::age));

还有另外一种List<Object>转换为Map<Object, Object>:

List<Person> personList = new ArrayList<>();Map<Long, Person> personMap = new HashMap<>();for (Person person : personList) {   personMap.put(person.getId(), person);}

使用Lambda简化：

Map<String, Person> groupMap = words.stream()    .collect(Collectors.toMap(Person::id, Function.identity(), (e1, e2) -> e1));

关于Stream的使用方法请参考：提高Java开发生产力，我选Stream,真香啊

使用函数式接口

现在有一个函数式接口：

@FunctionalInterfaceinterface MyInterface{    void doSomething(String s);}

常规做法在使用函数式接口时：

MyInterface myInterface = new MyInterface() {    @Override    public void doSomething(String s) {        System.out.println(s);    }};myInterface.doSomething("I am 码农Academy");

使用Lamba进行优化：

MyInterface myInterface = s -> System.out.println(s);myInterface.doSomething("I am 码农Academy");

线程创建

以往创建线程的方式：

Thread thread = new Thread(new Runnable() {    @Override    public void run() {        System.out.println("Hello, 码农Academy!");    }});

使用Lambda简化后：

Thread thread = new Thread(() -> System.out.println("Hello, 码农Academy!"));// 或者使用线程池方式ExecutorService executor = Executors.newFixedThreadPool(5); executor.execute(() -> longRunningTask());

Optional

Optional可以避免空指针异常。

Optional<String> optional = ...;if (optional.isPresent()) {    String value = optional.get();    // 处理value}

使用Lambda简化：

Optional<String> optional = ...;optional.ifPresent(value -> handleValue(value));

关于使用Optional解决空指针的用法，可以参考：聊一聊日常开发中如何避免那无处不在的让人头疼的NullPointerException

Stream的流水操作

在处理业务时，我们需要对一个集合进行一系列的操作时，比如如下：`

List<Integer> result = new ArrayList<>();for (String str : list) {    if (str.matches("//d+")) {        result.add(Integer.parseInt(str));    }}

利用Stream API与Lambda结合，实现链式操作，使代码更清晰易读：

List<Integer> result = list.stream()    .filter(str -> str.matches("//d+"))    .map(Integer::parseInt)    .collect(Collectors.toList());

比如我们使用Lambda结合Stream实现一个去重操作：

/**     * 根据学生姓名查询除重复元素     * @param students     */    private static void repeatStudentsTest(List<Student> students){        // list 对应的 Stream      List<String> repeatStudents =   students.stream()              // 获得元素出现频率的 Map，键为元素，值为元素出现的次数                .collect(Collectors.toMap(e -> e.getName(), e -> 1, Integer::sum))              // 所有 entry 对应的 Stream                .entrySet().stream()              // 过滤出元素出现次数大于 1 的 entry（过滤出来的是重复的，若这里条件是等于，即可达到去重的目的）                .filter(entry -> entry.getValue()>1)            // 获得 entry 的键（重复元素）对应的 Stream                .map(entry -> entry.getKey())              // 转化为 List                .collect(Collectors.toList());        repeatStudents.forEach(repeatStudent -> {            System.out.println(repeatStudent);        });    }

关于Stream的使用方法请参考：提高Java开发生产力，我选Stream,真香啊

Lambda的断点调试

关于使用Idea开发式，以前对代码断点时确实无法进入到lamda表达式里面，但是随着Idea的升级，已经解决了这个问题，可以在Lambda表达式的内部进行断点

图片

Lambda易读

有人可能会认为Lambda表达式的代码阅读起来有些吃力，当然也是可以理解，其主要原因有如下几个方面：

匿名性：Lambda表达式本质上是匿名函数，没有显式的方法名称，因此，初次接触或不熟悉其语法的读者可能难以快速理解其意图，尤其是在较复杂的上下文中。
简洁性：Lambda表达式的目的是为了简化代码，它往往非常紧凑，可能会把原本分散在多个行或方法中的逻辑压缩到一行甚至一部分内。这样的代码密度可能导致理解上的难度，特别是当逻辑较为复杂时。
抽象层次：Lambda表达式常与函数式接口一起使用，这意味着理解Lambda表达式需要知道它所对应接口的行为约定。如果读者不了解接口的具体功能，那么Lambda表达式就可能变得难以解读。
函数式编程范式：对于习惯于命令式编程风格的开发者来说，函数式编程的思维方式和Lambda表达式的使用可能需要一定适应期。尤其是涉及到闭包、高阶函数等概念时，如果不熟悉这些概念，理解Lambda表达式的逻辑会更加困难。
依赖上下文：Lambda表达式经常用于流(Stream)操作、事件监听、回调函数等场景，其含义高度依赖于上下文环境。在缺少充分注释或文档的情况下，阅读者可能需要花费更多精力去推理其作用。

但是，随着Java 8以来函数式编程特性的普及，越来越多的Coder们开始接受并熟练使用Lambda表达式。适当的代码组织、注释和遵循良好的编程规范有助于降低Lambda表达式带来的阅读障碍。并且随着经验的增长和技术背景的丰富，我们会逐渐认识到Lambda表达式的优点，即它可以增强代码的可读性和简洁性，尤其在处理数据流和进行函数组合时。

总结

熟练运用Lambda表达式能够显著提升代码质量与开发效率，使得代码逻辑更加简明扼要，同时也增强了程序的可读性与维护性。不断学习和实践这些技巧，你的开发效率必将迎来质的飞跃。并且Lambda与Stream一起使用才能发挥他们最大的优点。

本文链接：http://www.28at.com/showinfo-26-80890-0.html提高生产力！这10个Lambda表达式必须掌握，开发效率嘎嘎上升！

声明：本网页内容旨在传播知识，若有侵权等问题请及时与本网联系，我们将在第一时间删除处理。邮件：2376512515@qq.com

上一篇：分享七个你可能不知道的 Next.js 14 小技巧

下一篇： Exclude 工具类型八个使用技巧

标签：

热门焦点

官方承诺：K60至尊版将会首批升级MIUI 15

全新的MIUI 15今天也有了消息，在官宣了K60至尊版将会搭载天玑9200+处理器和独显芯片X7的同时，Redmi给出了官方承诺，K60至尊重大更新首批升级，会首批推送MIUI 15。也就是说虽然
K6：面向开发人员的现代负载测试工具

K6 是一个开源负载测试工具，可以轻松编写、运行和分析性能测试。它建立在 Go 和 JavaScript 之上，它被设计为功能强大、可扩展且易于使用。k6 可用于测试各种应用程序，包括 Web
三言两语说透柯里化和反柯里化

JavaScript中的柯里化(Currying)和反柯里化(Uncurrying)是两种很有用的技术，可以帮助我们写出更加优雅、泛用的函数。本文将首先介绍柯里化和反柯里化的概念、实现原理和应用
8月见！小米MIX Fold 3获得3C认证：支持67W快充

这段时间以来，包括三星、一加、荣耀等等有不少品牌旗下的最新折叠屏旗舰都得到了不少爆料，而小米新一代折叠屏旗舰——小米MIX Fold 3此前也屡屡被传
半导体需求下滑三星电子DS业务部门今年营业亏损预计超10万亿韩元

7月17日消息，据外媒报道，去年下半年开始的半导体需求下滑，影响到了三星电子、SK海力士、英特尔等诸多厂商，营收明显下滑，部分厂商甚至出现了亏损。作为
滴滴违法违规被罚80.26亿共存在16项违法事实

滴滴违法违规被罚80.26亿存在16项违法事实开始于2121年7月，历经一年时间，网络安全审查办公室对“滴滴出行”网络安全审查终于有了一个暂时的结束。据“网信
联想小新Pad Pro 12.6将要推出，搭载高通骁龙 870 处理器

联想小新Pad Pro 12.6将于秋季新品会上推出，官方按照惯例直接在发布会前给出了机型的所有参数。联想小新 Pad Pro 12.6 将搭载高通骁龙 870 处理器，重量为 5
“买真退假” 这种“羊毛”不能薅

□ 法治日报记者王春　　□ 本报通讯员胡佳丽　　2020年初，还在上大学的小东加入了一个大学生兼职QQ群。群主“七王”在群里介绍一些刷单赚