Java Lambda表达式:简化编程,提高效率

news2025/3/16 3:58:22

Java Lambda表达式:简化编程,提高效率

    • 1. 使用Lambda表达式进行集合遍历
      • 1.1 未使用Lambda表达式:
      • 1.2 使用Lambda表达式:
    • 2. 使用Lambda表达式进行排序
      • 2.1 未使用Lambda表达式:
      • 2.2 使用Lambda表达式:
    • 3. 使用Lambda表达式进行过滤
      • 3.1 未使用Lambda表达式:
      • 3.2 使用Lambda表达式:
    • 4. 使用Lambda表达式进行映射
      • 4.1 未使用Lambda表达式:
      • 4.2 使用Lambda表达式:
    • 5. 使用Lambda表达式进行归约
      • 5.1 未使用Lambda表达式:
      • 5.2 使用Lambda表达式:
    • 6. 使用Lambda表达式进行分组
      • 6.1 未使用Lambda表达式:
      • 6.2 使用Lambda表达式:
    • 源码
    • 7. 使用Lambda表达式进行函数式接口的实现
      • 7.1 未使用Lambda表达式:
      • 7.2 使用Lambda表达式:
    • 8. 使用Lambda表达式进行线程的创建
      • 8.1 未使用Lambda表达式:
      • 8.2 使用Lambda表达式:
    • 9. 使用Lambda表达式进行Optional的操作
      • 9.1 未使用Lambda表达式:
      • 9.2 使用Lambda表达式:
    • 10. 使用Lambda表达式进行Stream的流水线操作
      • 10.1 未使用Lambda表达式:
      • 10.2 使用Lambda表达式:

在这里插入图片描述

在这里插入图片描述

博主 默语带您 Go to New World.
个人主页—— 默语 的博客👦🏻
《java 面试题大全》
🍩惟余辈才疏学浅,临摹之作或有不妥之处,还请读者海涵指正。☕🍭
《MYSQL从入门到精通》数据库是开发者必会基础之一~
🪁 吾期望此文有资助于尔,即使粗浅难及深广,亦备添少许微薄之助。苟未尽善尽美,敬请批评指正,以资改进。!💻⌨

理解了,我将添加更多的案例,其中将包括对比使用Lambda表达式和不使用Lambda表达式的情况,以便更全面地展示Lambda表达式的优势。让我们开始扩展这个内容吧:

1. 使用Lambda表达式进行集合遍历

1.1 未使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
for (String fruit : list) {
    System.out.println(fruit);
}

1.2 使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
list.forEach(fruit -> System.out.println(fruit));

Lambda表达式的使用使得集合遍历更为简洁,消除了传统for循环中的冗余代码,提升了代码的可读性和简洁性。

2. 使用Lambda表达式进行排序

2.1 未使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, new Comparator<String>() {
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});

2.2 使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, (s1, s2) -> s1.compareTo(s2));

Lambda表达式的引入简化了排序操作的代码量,使得代码更加紧凑、易读。

3. 使用Lambda表达式进行过滤

3.1 未使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = new ArrayList<String>();
for (String fruit : list) {
    if (fruit.startsWith("a")) {
        filteredList.add(fruit);
    }
}

3.2 使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("a")).collect(Collectors.toList());

Lambda表达式简化了过滤操作,使得代码更加清晰明了,减少了中间变量的使用。

4. 使用Lambda表达式进行映射

4.1 未使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = new ArrayList<Integer>();
for (String fruit : list) {
    lengths.add(fruit.length());
}

4.2 使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = list.stream().map(fruit -> fruit.length()).collect(Collectors.toList());

Lambda表达式使得映射操作更加简洁明了,减少了循环代码的编写。

5. 使用Lambda表达式进行归约

5.1 未使用Lambda表达式:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (int i : list) {
    sum += i;
}

5.2 使用Lambda表达式:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, (a, b) -> a + b);

Lambda表达式的引入使得归约操作更为简单,减少了冗余的循环代码,提高了代码的可读性和简洁性。

以上是对常见操作的Lambda表达式应用,接下来我们将继续探讨Lambda表达式在其他方面的应用,包括函数式接口的实现、线程创建、Optional的操作以及Stream的流水线操作。

6. 使用Lambda表达式进行分组

6.1 未使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Integer, List<String>> grouped = new HashMap<Integer, List<String>>();
for (String fruit : list) {
    int length = fruit.length();
    if (!grouped.containsKey(length)) {
        grouped.put(length, new ArrayList<String>());
    }
    grouped.get(length).add(fruit);
}

6.2 使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Integer, List<String>> grouped = list.stream().collect(Collectors.groupingBy(String::length));

Lambda表达式使得分组操作更加简洁,通过方法引用或Lambda表达式,能够直接传递业务逻辑,减少了样板代码的编写。

源码

package com.example.java;

import java.util.*;
import java.util.stream.Collectors;

public class lamdba {

    public static void main(String[] args) {


        List<String> list = Arrays.asList("apple", "orange", "banana");
        //todo---------------------------------------------------

        //1.集合遍历
        for (String s : list) {
            System.out.println("普通编码==》" + s);
        }
        list.forEach(s -> System.out.println("Lambda遍历==》" + s));

        //2.排序
        // 使用 Collections.sort() 方法对列表 list 进行排序
        Collections.sort(list, new Comparator<String>() {
            // 创建匿名内部类实现 Comparator 接口,并重写 compare 方法
            @Override
            public int compare(String o1, String o2) {
                // 比较两个字符串 o1 和 o2 的字典顺序(升序)
                return o1.compareTo(o2);
            }
        });
        // 输出排序后的列表
        System.out.println("普通排序:" + list);

        Collections.sort(list, (s1, s2) -> s1.compareTo(s2));
        System.out.println("Lambda排序:" + list);


        //3.过滤
        // 创建一个新的列表 filteredList,用于存储过滤后的字符串
        List<String> filteredList = new ArrayList<String>();

// 使用增强型 for 循环遍历原始列表 list 中的每个元素
        for (String s : list) {
            // 检查当前字符串 s 是否以字母 "a" 开头
            if (s.startsWith("a")) {
                // 如果是以 "a" 开头,则将其添加到过滤后的列表 filteredList 中
                filteredList.add(s);
            }
        }

// 输出过滤后的列表内容
        System.out.println("普通过滤:" + filteredList);


        // 使用流式处理和 Lambda 表达式过滤原始列表 list 中以字母 "b" 开头的字符串
        List<String> filtered = list.stream()
                .filter(fruit -> fruit.startsWith("b")) // 使用 filter() 方法过滤符合条件的元素
                .collect(Collectors.toList()); // 将过滤后的结果收集到新的列表中

// 输出 Lambda 过滤后的列表内容
        System.out.println("Lambda过滤:" + filtered);


        //4.映射
        List<Integer> lengths = new ArrayList<Integer>();
        for (String s : list) {
            lengths.add(s.length());
        }
        System.out.println("普通映射:" + lengths);

// 使用流式处理将原始列表 list 中的字符串转换为它们的长度,并收集到新的整数列表中
        List<Integer> length = list.stream()                // 将列表转换为一个流
                .map(fruit -> fruit.length())   // 使用 map() 方法将每个字符串映射为其长度
                .collect(Collectors.toList());  // 将映射后的长度收集到一个新的整数列表中
        System.out.println("Lambda映射:" + lengths);


        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);


        //5.归约
        int sum = 0;
        for (int i : list1) {
            sum += i;
        }
        System.out.println("普通归约" + sum);


// 使用流式处理将列表 list 中的所有元素进行求和操作
        int sum1 = list1.stream()                   // 将列表转换为一个流
                .reduce(0, (a, b) -> a + b); // 使用 reduce() 方法对流中的元素进行累加求和,初始值为 0

        System.out.println("Lambda归约" + sum1);


        //6.分组
        // 创建一个 HashMap,用于按字符串长度将列表 list 中的字符串分组
        Map<Integer, List<String>> grouped = new HashMap<Integer, List<String>>();

// 遍历列表 list 中的每个字符串
        for (String s : list) {
            // 获取当前字符串 s 的长度
            int lengths1 = s.length();

            // 如果 grouped 中不包含当前长度,则添加一个新的列表
            if (!grouped.containsKey(lengths1)) {
                grouped.put(lengths1, new ArrayList<String>());
            }

            // 将当前字符串 s 加入到对应长度的列表中
            grouped.get(lengths1).add(s);
        }

// 输出普通分组结果
        System.out.println("普通分组:" + grouped);


// 使用流式处理将列表 list 中的字符串按照它们的长度进行分组,并收集到一个新的 Map 中
        Map<Integer, List<String>> groupeds = list.stream()   // 将列表转换为一个流
                .collect(Collectors.groupingBy(fruit -> fruit.length())); // 使用 groupingBy() 方法按字符串长度进行分组

        System.out.println("Lambda分组:" + groupeds);









    }
}

执行结果

普通编码==》apple
普通编码==》orange
普通编码==》banana
Lambda遍历==》apple
Lambda遍历==》orange
Lambda遍历==》banana
普通排序:[apple, banana, orange]
Lambda排序:[apple, banana, orange]
普通过滤:[apple]
Lambda过滤:[banana]
普通映射:[5, 6, 6]
Lambda映射:[5, 6, 6]
普通归约15
Lambda归约15
普通分组:{5=[apple], 6=[banana, orange]}
Lambda分组:{5=[apple], 6=[banana, orange]}

7. 使用Lambda表达式进行函数式接口的实现

7.1 未使用Lambda表达式:

public interface MyInterface {
    public void doSomething(String input);
}

MyInterface myObject = new MyInterface() {
    public void doSomething(String input) {
        System.out.println(input);
    }
};
myObject.doSomething("Hello World");

7.2 使用Lambda表达式:

MyInterface myObject = input -> System.out.println(input);
myObject.doSomething("Hello World");

Lambda表达式使得函数式接口的实现更加简洁,通过箭头操作符直接定义了函数的行为,减少了接口实现类的创建。

8. 使用Lambda表达式进行线程的创建

8.1 未使用Lambda表达式:

Thread thread = new Thread(new Runnable() {
    public void run() {
        System.out.println("Thread is running.");
    }
});
thread.start();

8.2 使用Lambda表达式:

Thread thread = new Thread(() -> System.out.println("Thread is running."));
thread.start();

Lambda表达式简化了线程的创建过程,使得代码更为紧凑、易读。

9. 使用Lambda表达式进行Optional的操作

9.1 未使用Lambda表达式:

String str = "Hello World";
if (str != null) {
    System.out.println(str.toUpperCase());
}

9.2 使用Lambda表达式:

Optional<String> str = Optional.ofNullable("Hello World");
str.map(String::toUpperCase).ifPresent(System.out::println);

Lambda表达式使得对Optional对象的操作更加直观,通过链式调用的方式简化了代码的编写。

10. 使用Lambda表达式进行Stream的流水线操作

10.1 未使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = new ArrayList<String>();
for (String fruit : list) {
    if (fruit.startsWith("a")) {
        filteredList.add(fruit.toUpperCase());
    }
}
Collections.sort(filteredList);

10.2 使用Lambda表达式:

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream()
                               .filter(fruit -> fruit.startsWith("a"))
                               .map(String::toUpperCase)
                               .sorted()
                               .collect(Collectors.toList());

Lambda表达式简化了Stream流水线操作的代码,使得代码更为清晰、易读。

通过以上对比,我们可以清晰地看到Lambda表达式相比传统方式的优势,它使得代码更为简洁、可读,提高了编程效率。

🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅,敬请批评指正!🍁🐥

如对本文内容有任何疑问、建议或意见,请联系作者,作者将尽力回复并改进📓;(联系微信:Solitudemind )

点击下方名片,加入IT技术核心学习团队。一起探索科技的未来,共同成长。

在这里插入图片描述
在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1453167.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

智能摄像头prv文件恢复案例

家用智能摄像头一般采用的是mp4或者mov视频方案&#xff0c;常见的是mp4&#xff0c;对于部分有开发能力的厂商可能会采用自定义方案&#xff08;如360的bin文件&#xff09;,今天我们来看一个小厂的PRV自定义文件的恢复案例。 故障存储: 32G TF卡/fat32/ 簇&#xff08;块)大…

单片机移植Lua(STM32H743移植Lua-5.4.6)

文章目录 目的移植演示示例链接更多说明合理设置内存大小按需加载标准库实现系统和IO接口设置引用路径 总结 目的 通常单片机都是使用C/C来开发的&#xff0c;任何修改都需要重新编译固件然后下载运行。在一些需要灵活性更强的场合中可以内嵌Lua解释器实现动态更新应用程序的功…

算法——数论——同余

目录 同余 一、试题 算法训练 同余方程 同余 同余使人们能够用等式的形式简洁地描述整除关系同余&#xff1a;若 m&#xff08;正整数&#xff09;&#xff0c;a 和 b 是整数&#xff0c;a%mb%m&#xff0c;或(a-b)%m0&#xff0c;记为 a b(mod m)求解一元线性同余方程等价于…

Swift Combine 使用 ObservableObject 与 SwiftUI 模型作为发布源 从入门到精通二十

Combine 系列 Swift Combine 从入门到精通一Swift Combine 发布者订阅者操作者 从入门到精通二Swift Combine 管道 从入门到精通三Swift Combine 发布者publisher的生命周期 从入门到精通四Swift Combine 操作符operations和Subjects发布者的生命周期 从入门到精通五Swift Com…

PLC_博图系列☞GRAPH

PLC_博图系列☞GRAPH 文章目录 PLC_博图系列☞GRAPH背景介绍GRAPH优势局限性 顺序控制系统的模块 关键字&#xff1a; PLC、 西门子、 博图、 Siemens 、 GRAPH 背景介绍 这是一篇关于PLC编程的文章&#xff0c;特别是关于西门子的博图软件。我并不是专业的PLC编程人员&am…

【Redis实战】有MQ为啥不用?用Redis作消息队列!?Redis作消息队列使用方法及底层原理高级进阶

&#x1f389;&#x1f389;欢迎光临&#x1f389;&#x1f389; &#x1f3c5;我是苏泽&#xff0c;一位对技术充满热情的探索者和分享者。&#x1f680;&#x1f680; &#x1f31f;特别推荐给大家我的最新专栏《Redis实战与进阶》 本专栏纯属为爱发电永久免费&#xff01;&a…

报文鉴别、实体鉴别

目录 鉴别 1 报文鉴别 1.1 用数字签名进行鉴别&#xff08;原理&#xff09; 可保证机密性的数字签名 1.2 密码散列函数 MD5 算法 MD5 算法计算步骤 安全散列算法 SHA-1 1.3 用报文鉴别码实现报文鉴别 用报文鉴别码 MAC 鉴别报文 使用已签名的报文鉴别码 MAC 对报…

工程师日常:海丰县附城镇鹿境元宵开灯活动

海丰县附城镇鹿境元宵开灯活动 &#xff08;蔡惠进搜集整理&#xff09; 鹿境乡春节正月初十大老热&#xff0c;全县家喻户晓。为纪念先祖功德&#xff0c;在本乡车地建立蔡氏“济阳堂”大祖祠&#xff0c;并定年初十为开灯日&#xff0c;大祖开灯代代相传。凡移居外乡裔孙、“…

机器学习8-决策树

决策树&#xff08;Decision Tree&#xff09;是一种强大且灵活的机器学习算法&#xff0c;可用于分类和回归问题。它通过从数据中学习一系列规则来建立模型&#xff0c;这些规则对输入数据进行递归的分割&#xff0c;直到达到某个终止条件。 决策树的构建过程&#xff1a; 1.…

java 宠物医院系统Myeclipse开发mysql数据库web结构jsp编程计算机网页项目

一、源码特点 java 宠物医院系统是一套完善的java web信息管理系统&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。开发环境为TOMCAT7.0,Myeclipse8.5开发&#xff0c;数据库为Mysql5.0&…

463. Island Perimeter(岛屿的周长)

问题描述 给定一个 row x col 的二维网格地图 grid &#xff0c;其中&#xff1a;grid[i][j] 1 表示陆地&#xff0c; grid[i][j] 0 表示水域。 网格中的格子 水平和垂直 方向相连&#xff08;对角线方向不相连&#xff09;。整个网格被水完全包围&#xff0c;但其中恰好有…

希捷与索尼集团合作生产HAMR写头激光二极管

最近有报道指出&#xff0c;希捷&#xff08;Seagate&#xff09;在生产其采用热辅助磁记录&#xff08;HAMR&#xff09;技术的大容量硬盘时&#xff0c;并非所有组件都在内部制造。根据日经新闻的一份新报告&#xff0c;希捷已与索尼集团合作&#xff0c;由索尼为其HAMR写头生…

qml中边界图片BorderImage的使用

1、基本概念 2、案例 原图&#xff0c;120*120像素 &#xff08;1&#xff09;水平和垂直方向上都设置为拉伸模式 import QtQuick 2.12 import QtQuick.Window 2.12 import QtQuick.Controls 2.12 import QtQuick.Layouts 1.12ApplicationWindow {id: windowvisible: truew…

【c语言】人生重开模拟器

前言&#xff1a; 人生重开模拟器是前段时间非常火的一个小游戏&#xff0c;接下来我们将一起学习使用c语言写一个简易版的人生重开模拟器。 网页版游戏&#xff1a; 人生重开模拟器 (ytecn.com) 1.实现一个简化版的人生重开模拟器 &#xff08;1&#xff09; 游戏开始的时…

【学习笔记】一文打通Docker!(项目部署orCTF)

Docker What is Docker? 利用Docker 可以快速安装应用&#xff0c;Docker会自动搜索并下载应用镜像(image)。镜像不仅包含应用本身&#xff0c;还包含应用运行所需要的环境&#xff0c;配置&#xff0c;系统函数库。 注意这个系统函数库&#xff0c;相当于在不同的操作版本…

反向迭代器------封装的力量

目录 一、list封装中模板参数Ref和Ptr的理解 二、反向迭代器的实现 一、list封装中模板参数Ref和Ptr的理解 对于反向迭代器&#xff0c;是我们在前面STL模拟实现中留下的一个问题。在之前的文章中&#xff0c;我们极大程度上的利用了模板&#xff0c;从而减少了许多的代码&…

【半监督图像分割 2023 】BHPC

【半监督图像分割 2023 】BHPC 论文题目&#xff1a;Semi-supervised medical image segmentation via hard positives oriented contrastive learning 中文题目&#xff1a;通过面向硬阳性的对比学习进行半监督医学图像分割 论文链接&#xff1a; 论文代码&#xff1a;https:/…

CCF编程能力等级认证GESP—C++6级—20231209

CCF编程能力等级认证GESP—C6级—20231209 单选题&#xff08;每题 2 分&#xff0c;共 30 分&#xff09;判断题&#xff08;每题 2 分&#xff0c;共 20 分&#xff09;编程题 (每题 25 分&#xff0c;共 50 分)闯关游戏工作沟通 答案及解析单选题判断题编程题1编程题2 单选题…

Midjourney绘图欣赏系列(五)

Midjourney介绍 Midjourney 是生成式人工智能的一个很好的例子&#xff0c;它根据文本提示创建图像。它与 Dall-E 和 Stable Diffusion 一起成为最流行的 AI 艺术创作工具之一。与竞争对手不同&#xff0c;Midjourney 是自筹资金且闭源的&#xff0c;因此确切了解其幕后内容尚不…

2024023期传足14场胜负前瞻

新的一年祝大家行大运、发大财、中大奖&#xff01;2024023期赛事由英超2场&#xff0c;德甲2场、意甲4场、西甲3场、法甲3场组成。售止时间为2月18日&#xff08;周六&#xff09;21点30分&#xff0c;敬请留意&#xff1a; 本期中深盘较少&#xff0c;1.5以下赔率仅1场&#…