Java Lambda表达式：简化编程，提高效率

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技术核心学习团队。一起探索科技的未来，共同成长。

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Sora：将文本转化为视频的创新之旅

Sora：将文本转化为视频的创新之旅

一.能力 我们正致力于让 AI 掌握理解和模拟物理世界动态的能力&#xff0c;旨在培养能够协助人们解决现实世界互动问题的模型。 介绍 Sora——我们开发的文本到视频转换模型。Sora 能够根据用户的输入提示&#xff0c;生成最长达一分钟的高质量视频内容。 目前&#xff0c;Sora…
阅读更多...
MCU中断控制

MCU中断控制

目录 一、中断相关基础知识 1、NVIC&#xff1a;嵌套向量中断控制器 2、可屏蔽中断和不可屏蔽中断的区别 3、中断优先级 4、常见特殊中断 二、中断相关寄存器 三、中断使用步骤&#xff1a; 一、中断相关基础知识 1、NVIC&#xff1a;嵌套向量中断控制器 (1) 它是内核的…
阅读更多...
1.8 NLP自然语言处理

1.8 NLP自然语言处理

NLP自然语言处理 更多内容&#xff0c;请关注&#xff1a; github&#xff1a;https://github.com/gotonote/Autopilot-Notes.git 一、简介 seq2seq(Sequence to Sequence)是一种输入不定长序列&#xff0c;产生不定长序列的模型&#xff0c;典型的处理任务是机器翻译&#…
阅读更多...
2.15练习

2.15练习

选择题 1. B2. B3. C4. D5. A6. B7. C8. B9. D10. B11. A12. B 填空题 1. a b c 2.string s: I like it. String t:A like it. 3. 30 10 30 n Learning
阅读更多...
【复合多尺度熵与特征提取】一文看懂“复合多尺度熵”——复合多尺度样本熵、模糊熵、排列熵、包络熵、功率谱熵、能量熵、奇异谱熵及其MATLAB实现

【复合多尺度熵与特征提取】一文看懂“复合多尺度熵”——复合多尺度样本熵、模糊熵、排列熵、包络熵、功率谱熵、能量熵、奇异谱熵及其MATLAB实现

在上一篇文章中&#xff0c;我们讲了多尺度熵的原理及MATLAB实现。 本篇要讲的是多尺度熵的一个改进特征提取方法——复合多尺度熵&#xff08;Composite Multiscale Entropy, CMSE&#xff09;。复合多尺度熵方法不仅继承了多尺度熵在揭示时间序列多尺度复杂性方面的优势&…
阅读更多...
力扣题目训练（12）

力扣题目训练（12）

2024年2月5日力扣题目训练 2024年2月5日力扣题目训练476. 数字的补数482. 密钥格式化485. 最大连续 1 的个数148. 排序链表164. 最大间距 2024年2月5日力扣题目训练 2024年2月5日第十二天编程训练&#xff0c;今天主要是进行一些题训练&#xff0c;包括简单题3道、中等题2道和…
阅读更多...
c高级day4作业

c高级day4作业

终端输入一个字符&#xff0c;判断是大写字母小写字母还是数字字符。 #!/bin/bash read -p "input字符--->" a case $a in[[:upper:]])echo 大写字母$a;;[[:lower:]])echo 小写字母$a;;[0-9])echo 数字字符$a;;*)echo "error" esac终端输入年月&#x…
阅读更多...
GIS 基于 MCDM-AHP 方法研究潜在风力发电厂区域

GIS 基于 MCDM-AHP 方法研究潜在风力发电厂区域

随着全球人口的迅速增长、现有不可再生能源的不足以及工业的快速发展，人们对可再生能源的兴趣与日俱增。除了化石燃料的有限供应外，由于无法避免其对环境造成的破坏，人们开始转向替代能源。风能是最具商业价值的能源之一，既环保又可持续。然而，为了使风力发电厂发挥最大效…
阅读更多...
⭐北邮复试刷题103. 二叉树的锯齿形层序遍历

⭐北邮复试刷题103. 二叉树的锯齿形层序遍历

103. 二叉树的锯齿形层序遍历 给你二叉树的根节点 root &#xff0c;返回其节点值的 锯齿形层序遍历 。&#xff08;即先从左往右&#xff0c;再从右往左进行下一层遍历&#xff0c;以此类推&#xff0c;层与层之间交替进行&#xff09;。 示例 1&#xff1a;输入&#xff1a…
阅读更多...
链式结构实现队列

链式结构实现队列

链式结构实现队列 1.队列1.1队列的概念及结构1.2队列的实现 2. 队列的各种函数实现3. 队列的全部代码实现 1.队列 1.1队列的概念及结构 队列&#xff1a;只允许在一端进行插入数据操作&#xff0c;在另一端进行删除数据操作的特殊线性表&#xff0c;队列具有先进先出 FIFO(Fi…
阅读更多...
深入解析域名短链接生成原理及其在Python/Flask中的实现策略：一篇全面的指南与代码示例

深入解析域名短链接生成原理及其在Python/Flask中的实现策略：一篇全面的指南与代码示例

为了构建一个高效且用户友好的域名短链服务&#xff0c;我们可以将项目精简为以下核心功能板块&#xff1a; 1. 用户管理 注册与登录&#xff1a;允许用户创建账户并登录系统。 这部分内容可以参考另一片文章实现&#xff1a; 快速实现用户认证&#xff1a;使用Python和Flask…
阅读更多...
Aster实现一台电脑当两台使——副屏使用独立win账号

Aster实现一台电脑当两台使——副屏使用独立win账号

前言&#xff1a;笔者每年回家&#xff0c;都面临着想要和小伙伴一起玩游戏&#xff0c;但小伙伴没有电脑/只有低配电脑的问题。与此同时&#xff0c;笔者自身的电脑是高配置的电脑&#xff0c;因此笔者想到&#xff0c;能否在自己的电脑上运行游戏&#xff0c;在小伙伴的电脑上…
阅读更多...
得物面试：Redis用哈希槽，而不是一致性哈希，为什么？

得物面试：Redis用哈希槽，而不是一致性哈希，为什么？

尼恩说在前面 在40岁老架构师 尼恩的读者交流群(50)中&#xff0c;最近有小伙伴拿到了一线互联网企业如得物、阿里、滴滴、极兔、有赞、希音、百度、网易、美团的面试资格&#xff0c;遇到很多很重要的面试题&#xff1a; Redis为何用哈希槽而不用一致性哈希&#xff1f; 最近…
阅读更多...
智能传感器阅读笔记-智能传感器的发展历程、发展趋势及方向

智能传感器阅读笔记-智能传感器的发展历程、发展趋势及方向

智能传感器的发展历程 第一代智能传感器 第一代智能传感器是数字式传感器&#xff0c;指改造A/D转换模块&#xff0c;并采用数字技术进行信号处理&#xff0c;使输出信号为数字信号&#xff08;或数字编码&#xff09;的传感器&#xff0c;主要由放大器、A/D转换模块、微处理…
阅读更多...
解决STM32MP157开发板密码登录问题

解决STM32MP157开发板密码登录问题

开发板密码登录问题是很多人遇到的问题&#xff0c;网上有很多帖子&#xff0c;我也参考过&#xff0c;不太适用&#xff0c;很复杂&#xff0c;甚至会被误导&#xff0c;我差点连ubuntu虚拟机都无法登录了。有的密码匹配&#xff0c;有的取消不了密码。 1、密码配置&#xff…
阅读更多...
ABC341 A-F

ABC341 A-F

Toyota Programming Contest 2024#2&#xff08;AtCoder Beginner Contest 341&#xff09; - AtCoder B读不懂题卡了&#xff0c;F读假题卡了&#xff0c;开题开慢了rank了 A - Print 341 题意&#xff1a; 打印一串交替出现的包含N个0&#xff0c;N1个1的01串 代码&…
阅读更多...
【案例8】用户中心实现涉及内容和过程

【案例8】用户中心实现涉及内容和过程

图1 如图1是用盒子模型内容实现的&#xff0c;但是需要了解一些内容。 一.内容知识引入 1.内边距属性&#xff08;padding&#xff09; 为了调整盒子在网页中的显示位置&#xff0c;常常需要为元素设置内边距。内边距也被称为内填充&#xff0c;是指元素内容和边框之间的距离…
阅读更多...
Windows程序互斥锁 - 一个程序同时仅允许运行一个实例

Windows程序互斥锁 - 一个程序同时仅允许运行一个实例

Windows程序互斥锁 - 一个程序同时仅允许运行一个实例 前言 鉴于应用逻辑需要&#xff0c;有些Windows应用同时只能运行一个实例。例如&#xff1a;一个电脑只能同时运行一个微信&#xff08;手速快了当我没说&#xff0c;不信你去试试&#xff09;。 怎么实现呢&#xff1f…
阅读更多...
Unity 减低GC和优化

Unity 减低GC和优化

文章目录 在Unity中&#xff0c;垃圾收集&#xff08;Garbage Collection, GC&#xff09;是一项重要的内存管理机制&#xff0c;但过度的GC活动可能会导致性能瓶颈。优化Unity项目中的GC涉及减少不必要的对象分配和生命周期管理。以下列举了五个实例来详细说明如何降低GC负担并…
阅读更多...
前端工程化面试题 | 11.精选前端工程化高频面试题

前端工程化面试题 | 11.精选前端工程化高频面试题

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
最新文章

Copyright @ 2022~2023