首页 > 其他分享 >Lambda表达式：会这10招

Lambda表达式：会这10招

时间：2024-06-18 09:16:05浏览次数：24  
标签：10 java List util import public 表达式 Lambda

引言
在Java 8之前，Java的语法相对冗长，尤其是在处理集合操作和多线程编程时，常常需要大量的样板代码。

自Java 8引入Lambda表达式以来，Java编程变得更加简洁和高效，不仅减少了代码量，还提升了代码的可读性和可维护性。

今天就来聊聊几种工作中很常用的Lambda表达式应用场景，走过路过别错过哦~

  1. 集合遍历
    传统方式：

import java.util.Arrays;
import java.util.List;

public class TraditionalForEach {
public static void main(String[] args) {
// 创建一个包含三个元素的列表
List list = Arrays.asList("a", "b", "c");
// 使用传统的for-each循环遍历列表并打印每个元素
for (String item : list) {
System.out.println("传统方式遍历元素: " + item);
}
}
}
Lambda表达式：

import java.util.Arrays;
import java.util.List;

public class LambdaForEach {
public static void main(String[] args) {
// 创建一个包含三个元素的列表
List list = Arrays.asList("a", "b", "c");
// 使用Lambda表达式遍历列表并打印每个元素
list.forEach(item -> System.out.println("Lambda方式遍历元素: " + item));
}
}
输出结果：

传统方式遍历元素: a
传统方式遍历元素: b
传统方式遍历元素: c
Lambda方式遍历元素: a
Lambda方式遍历元素: b
Lambda方式遍历元素: c
2. 集合排序
传统方式：

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class TraditionalSort {
public static void main(String[] args) {
// 创建一个未排序的列表
List list = Arrays.asList("b", "a", "c");
// 使用传统方式进行排序
Collections.sort(list, new Comparator() {
@Override
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
});
// 打印排序后的列表
System.out.println("传统方式排序结果: " + list);
}
}
Lambda表达式：

import java.util.Arrays;
import java.util.List;

public class LambdaSort {
public static void main(String[] args) {
// 创建一个未排序的列表
List list = Arrays.asList("b", "a", "c");
// 使用Lambda表达式进行排序
list.sort((s1, s2) -> s1.compareTo(s2));
// 打印排序后的列表
System.out.println("Lambda方式排序结果: " + list);
}
}
输出结果：

传统方式排序结果: [a, b, c]
Lambda方式排序结果: [a, b, c]
3. 集合过滤
传统方式：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TraditionalFilter {
public static void main(String[] args) {
// 创建一个列表
List list = Arrays.asList("a", "b", "c", "aa");
// 创建一个新的列表来存储过滤后的结果
List filteredList = new ArrayList<>();
// 使用传统方式进行过滤
for (String item : list) {
if (item.startsWith("a")) {
filteredList.add(item);
}
}
// 打印过滤后的列表
System.out.println("传统方式过滤结果: " + filteredList);
}
}
Lambda表达式：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaFilter {
public static void main(String[] args) {
// 创建一个列表
List list = Arrays.asList("a", "b", "c", "aa");
// 使用Lambda表达式进行过滤并收集结果
List filteredList = list.stream()
.filter(item -> item.startsWith("a"))
.collect(Collectors.toList());
// 打印过滤后的列表
System.out.println("Lambda方式过滤结果: " + filteredList);
}
}
输出结果：

传统方式过滤结果: [a, aa]
Lambda方式过滤结果: [a, aa]
4. 映射操作
传统方式：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TraditionalMap {
public static void main(String[] args) {
// 创建一个包含字符串数字的列表
List list = Arrays.asList("1", "2", "3");
// 创建一个新的列表来存储映射后的结果
List mappedList = new ArrayList<>();
// 使用传统方式进行映射
for (String item : list) {
mappedList.add(Integer.parseInt(item));
}
// 打印映射后的列表
System.out.println("传统方式映射结果: " + mappedList);
}
}
Lambda表达式：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaMap {
public static void main(String[] args) {
// 创建一个包含字符串数字的列表
List list = Arrays.asList("1", "2", "3");
// 使用Lambda表达式进行映射并收集结果
List mappedList = list.stream()
.map(Integer::parseInt)
.collect(Collectors.toList());
// 打印映射后的列表
System.out.println("Lambda方式映射结果: " + mappedList);
}
}
输出结果：

传统方式映射结果: [1, 2, 3]
Lambda方式映射结果: [1, 2, 3]
5. 计算操作
传统方式：

import java.util.Arrays;
import java.util.List;

public class TraditionalReduce {
public static void main(String[] args) {
// 创建一个包含数字的列表
List list = Arrays.asList(1, 2, 3, 4, 5);
// 使用传统方式进行求和
int sum = 0;
for (Integer num : list) {
sum += num;
}
// 打印求和结果
System.out.println("传统方式求和结果: " + sum);

    // 计算平均值
    double average = sum / (double) list.size();
    // 打印平均值结果
    System.out.println("传统方式求平均值结果: " + average);
}

}
Lambda表达式：

import java.util.Arrays;
import java.util.List;
import java.util.OptionalDouble;

public class LambdaReduce {
public static void main(String[] args) {
// 创建一个包含数字的列表
List list = Arrays.asList(1, 2, 3, 4, 5);
// 使用Lambda表达式进行求和
int sum = list.stream()
.mapToInt(Integer::intValue)
.sum();
// 打印求和结果
System.out.println("Lambda方式求和结果: " + sum);

    // 使用Lambda表达式计算平均值
    OptionalDouble average = list.stream()
                                 .mapToInt(Integer::intValue)
                                 .average();
    // 打印平均值结果
    System.out.println("Lambda方式求平均值结果: " + average.getAsDouble());
}

}
输出结果：

传统方式求和结果: 15
传统方式求平均值结果: 3.0
Lambda方式求和结果: 15
Lambda方式求平均值结果: 3.0
6. 分组操作
传统方式：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TraditionalGrouping {
public static void main(String[] args) {
// 创建一个包含字符串的列表
List list = Arrays.asList("a", "bb", "ccc", "dd", "eee");
// 创建一个Map来存储分组结果
Map<Integer, List> groupedByLength = new HashMap<>();
// 使用传统方式进行分组
for (String item : list) {
int length = item.length();
if (!groupedByLength.containsKey(length)) {
groupedByLength.put(length, new ArrayList<>());
}
groupedByLength.get(length).add(item);
}
// 打印分组结果
System.out.println("传统方式分组结果: " + groupedByLength);
}
}
Lambda表达式：

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class LambdaGrouping {
public static void main(String[] args) {
// 创建一个包含字符串的列表
List list = Arrays.asList("a", "bb", "ccc", "dd", "eee");
// 使用Lambda表达式进行分组并收集结果
Map<Integer, List> groupedByLength = list.stream()
.collect(Collectors.groupingBy(String::length));
// 打印分组结果
System.out.println("Lambda方式分组结果: " + groupedByLength);
}
}
输出结果：

传统方式分组结果: {1=[a], 2=[bb, dd], 3=[ccc, eee]}
Lambda方式分组结果: {1=[a], 2=[bb, dd], 3=[ccc, eee]}
7. 函数式接口
传统方式：

public class TraditionalFunctionalInterface {
public static void main(String[] args) {
// 使用传统方式创建线程
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("传统方式创建线程");
}
};
new Thread(runnable).start();
}
}
Lambda表达式：

public class LambdaFunctionalInterface {
public static void main(String[] args) {
// 使用Lambda表达式创建线程
Runnable runnable = () -> System.out.println("Lambda方式创建线程");
new Thread(runnable).start();
}
}
8. Optional
传统方式：

import java.util.Optional;

public class TraditionalOptional {
public static void main(String[] args) {
// 创建一个Optional对象
Optional optional = Optional.of("hello");
// 使用传统方式检查并打印值
if (optional.isPresent()) {
System.out.println("传统方式Optional值: " + optional.get());
}
}
}
Lambda表达式：

import java.util.Optional;

public class LambdaOptional {
public static void main(String[] args) {
// 创建一个Optional对象
Optional optional = Optional.of("hello");
// 使用Lambda表达式检查并打印值
optional.ifPresent(value -> System.out.println("Lambda方式Optional值: " + value));
}
}
输出结果：

传统方式Optional值: hello
Lambda方式Optional值: hello
9. Stream流水操作
传统方式：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class TraditionalStream {
public static void main(String[] args) {
// 创建一个包含字符串的列表
List list = Arrays.asList("a", "bb", "ccc", "dd", "eee");
// 创建一个新的列表来存储过滤和映射后的结果
List result = new ArrayList<>();
// 使用传统方式进行过滤和映射
for (String s : list) {
if (s.length() > 1) {
result.add(s.toUpperCase());
}
}
// 使用传统方式进行排序
Collections.sort(result, new Comparator() {
@Override
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
});
// 打印最终结果
System.out.println("传统方式Stream操作结果: " + result);
}
}
Lambda表达式：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaStream {
public static void main(String[] args) {
// 创建一个包含字符串的列表
List list = Arrays.asList("a", "bb", "ccc", "dd", "eee");
// 使用Lambda表达式进行过滤、映射、排序并收集结果
List result = list.stream()
.filter(s -> s.length() > 1)
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());
// 打印最终结果
System.out.println("Lambda方式Stream操作结果: " + result);
}
}
输出结果：

传统方式Stream操作结果: [BB, CCC, DD, EEE]
Lambda方式Stream操作结果: [BB, CCC, DD, EEE]
10. 扩展易读性
尽管Lambda表达式简洁高效，但有时也会降低代码的可读性。

为了提高可读性，可以适当地为复杂的Lambda表达式提供注释，或者将其提取为具有描述性名称的方法。

示例代码：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaReadability {
public static void main(String[] args) {
List list = Arrays.asList("a", "bb", "ccc", "dd", "eee");
List result = list.stream()
.filter(this::isLongerThanOne)
.map(this::toUpperCase)
.sorted()
.collect(Collectors.toList());
System.out.println("提升可读性的Lambda操作结果: " + result);
}

// 判断字符串长度是否大于1
private boolean isLongerThanOne(String s) {
    return s.length() > 1;
}

// 将字符串转换为大写
private String toUpperCase(String s) {
    return s.toUpperCase();
}

}
输出结果：

提升可读性的Lambda操作结果: [BB, CCC, DD, EEE]
总结
Lambda表达式的出现，已经不可能脱离Java编程的方方面面了，可以说是Java编程今后的敲门砖。

没有接触过或者不熟练的程序员可能会觉得不太好学或者不好理解，其实根本不用担心。

随着AI的出现，Lambda表达式已经没有门槛了，对于Java程序员来说，只要业务清晰，那么不会也能写。

标签：10,java,List,util,import,public,表达式,Lambda
From： https://www.cnblogs.com/huft/p/18253632

相关文章

  • 6.16 10
    importtkinterastkfromtkinterimportttk,messageboxfromPILimportImage,ImageTkimportmysql.connectorimportdb_connectiondefupdate_mistake(conn,mistake_id,question,error_info,answer_analysis,thoughts,source,reason,difficulty,......
  • 6.17 10
    <?xmlversion="1.0"encoding="utf-8"?><RelativeLayoutxmlns:android="http://schemas.android.com/apk/res/android"xmlns:tools="http://schemas.android.com/tools"android:layou......
  • 每日一题-24-06-17 (P10218)(加倍！)
    看到异或直接想到线性基和trie很明显是trie从高到低一位位考虑，如果两个儿子都有，想使这一位为1，必须有一个变成加法然后就便利一下trie，记录一下剩余的体力和最小的加法的数就好了#include<bits/stdc++.h>usingnamespacestd;#definell__int128#definelstr[u][0]#define......
  • centos 7无需token编译安装freeswitch 1.10.11 ——筑梦之路
    准备工作安装编译工具和依赖包yumupdate-ysudoyuminstallepel-releasevimtcpdumpnet-tools.x86_64-ysudoyuminstallgcc-c++sqlite-develzlib-devellibcurl-develpcre-develspeex-develldns-devellibedit-developenssl-develgit-yyuminstallyasm......
  • 每日一题-24-06-17 (P10217)
    今年省选题，考场上竟然没做出来今天似乎直接一眼出来了就是枚举下\(m\)模\(n\)的余数然后解个方程即可#include<bits/stdc++.h>usingnamespacestd;#definelllonglongintT,n,X,Y;intx[100005],y[100005];lls[100005],t[100005],res,k;llsub_down(llx,lly){......
  • 代码随想录第10天 | 栈与队列part01
    题目：232.用栈实现队列思路：1.使用双栈，一个作为输入，一个作为输出代码：classMyQueue{private:stack<int>A,B;public:MyQueue(){}voidpush(intx){A.push(x);}intpop(){//删除A栈底元素并返回元素intresult=this->p......
  • 2024华为OD机试真题-出租车计费 、靠谱的车-(C++/Python)-C卷D卷-100分
    2024华为OD机试题库-(C卷+D卷)-(JAVA、Python、C++) 题目描述：程序员小明打了一辆出租车去上班。出于职业敏感，他注意到这辆出租车的计费表有点问题，总是偏大。出租车司机解释说他不喜欢数字4，所以改装了计费表，任何数字位置遇到数字4就直接跳过，其余功能都正常。比如：23再多......
  • 2024华为OD机试真题-API集群负载统计-(C++/Python)-C卷D卷-100分
     2024华为OD机试题库-(C卷+D卷)-(JAVA、Python、C++)题目描述某个产品的RESTfulAPI集合部署在服务器集群的多个节点上，近期对客户端访问日志进行了采集，需要统计各个API的访问频次，根据热点信息在服务器节点之间做负载均衡，现在需要实现热点信息统计查询功能。RESTfulAPI是......
  • 从头到尾实现CIFAR-10图像分类：数据预处理到模型优化
    在深度学习领域，图像分类任务是基础也是极其重要的一部分，CIFAR-10数据集是这类问题的经典数据集之一。本文将详细介绍如何加载和预处理CIFAR-10数据集，构建简单和复杂的神经网络模型，以及通过改进模型结构来优化分类性能。一、处理CIFAR-10数据集：数据加载与预处理详解1、CIFAR-......
  • A. Bear and Prime 100
    原题链接题解1.如果是一百以内的合数，那么一定可以由两个不大于50的质数组成2.交互题关键就在于询问和返回的结果cout<<''';fflush(stdout);cin>>...code#include<bits/stdc++.h>usingnamespacestd;boolcheck(intx){for(inti=2;i*i<=x;i++){i......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99