返回
首页
业界
电商
创业
访谈
手机
移动
报告
运营
建站
互联网+
系统
教程
搜索

简单聊聊工作中常用的Java Lambda表达式

2022-11-04 09:40:17

目录前言1.list转map2.filter()过滤3.foreach遍历4.groupingBy分组5.sorted+Comparator排序6.distinct去重7.findFir...

目录
前言
1. list转map
2. filter()过滤
3. foreach遍历
4. groupingBy分组
5. sorted+Comparator 排序
6.distinct去重
7. findFirst 返回第一个
8. anyMatch是否至少匹配一个元素
9. allMatch 匹配所有元素
10. map转换
11. Reduce
12. peek 打印个日志
13. Max，Min最大最小
14. count统计
15. 常用函数式接口

前言

日常开发中，我们很多时候需要用到Java 8的Lambda表达式，它允许把函数作为一个方法的参数，让我们的代码更优雅、更简洁。所以整理了一波工作中，我常用的，有哪些Lambda表达式。看完一定会有帮助的。

1. list转map

工作中，我们经常遇到list转map的案例。Collectors.toMap就可以把一javascript个list数组转成一个Map。代码如下：

publicclassTestLambda{

publicstaticvoidmain(String[]args){

List<UserInfo>userInfoList=newArrayList<>();
userInfoList.add(newUserInfo(1L,"捡田螺的小男孩",18));
userInfoList.add(newUserInfo(2L,"程序员田螺",27));
userInfoList.add(newUserInfo(2L,"捡瓶子的小男孩",26));

/**
*list转map
*使用Collectors.toMap的时候，如果有可以重复会报错，所以需要加(k1,k2)->k1
*(k1,k2)->k1表示，如果有重复的key,则保留第一个，舍弃第二个
*/
Map<Long,UserInfo>userInfoMap=userInfoList.stream().collect(Collectors.toMap(UserInfo::getUserId,userInfo->userInfo,(k1,k2)->k1));
userInfoMap.values().forEach(a->System.out.println(a.getUserName()));
}
}

运行结果

捡田螺的小男孩
程序员田螺

类似的，还有Collectors.toList()、Collectors.toSet()，表示把对应的流转化为list或者Set。

2. filter()过滤

从数组集合中，过滤掉不符合条件的元素，留下符合条件的元素。

List<UserInfo>userInfoList=newArrayList<>();
userInfoList.add(newUserInfo(1L,"捡田螺的小男孩",18));
userInfoList.add(newUserInfo(2L,"程序员田螺",27));
userInfoList.add(newUserInfo(3L,"捡瓶子的小男孩",26));

/**
*filter过滤，留下超过18岁的用户
*/
List<UserInfo>userInfoResultList=userInfoList.stream().filter(user->user.getAge()>18).collect(Collectors.toList());
userInfoResultList.forEach(a->System.out.println(a.getUserName()));

运行结果

程序员田螺
捡瓶子的小男孩

3. foreach遍历

foreach 遍历list，遍历map，真的很丝滑。

/**
*forEach遍历集合List列表
*/
List<String>userNameList=Arrays.asList("捡田螺的小男孩","程序员田螺","捡瓶子的小男孩");
userNameList.forEach(System.out::println);

HashMap<String,String>hashMap=newHashMap<>();
hashMap.put("公众号","捡田螺的小男孩");
hashMap.put("职业","程序员田螺");
hashMap.put("昵称","捡瓶子的小男孩");
/**
*forEach遍历集合Map
*/
hashMap.forEach((k,v)->System.out.println(k+":\t"+v));

运行结果

捡田螺的小男孩
程序员田螺
捡瓶子的小男孩
职业: 程序员田螺
公众号: 捡田螺的小男孩
昵称: 捡瓶子的小男孩

4. groupingBy分组

提到分组，相信大家都会想起SQL的group by。我们经常需要一个List做分组操作。比如，按城市分组用户。在Java8之前，是这么实现的：

List<UserInfo>originUserInfoList=newArrayList<>();
originUserInfoList.add(newUserInfo(1L,"捡田螺的小男孩",18,"深圳"));

originUserInfoList.add(newUserInfo(3L,"捡瓶子的小男孩",26,"湛江"));
originUserInfoList.add(newUserInfo(2L,"程序员田螺",27,"深圳"));
Map<String,List<UserInfo>>result=newHashMap<>();
for(UserInfouserInfo:originUserInfoList){
Stringcity=userInfo.getCity();
List<UserInfo>userInfos=result.get(city);
if(userInfos==null){
userInfos=newArrayList<>();
result.put(city,userInfos);
}
userInfos.add(userInfo);
}

而使用Java8的groupingBy分组器，清爽无比:

Map<String,List<UserInfo>>result=originUserInfoList.stream()
.collect(Collectors.groupingBy(UserInfo::getCity));

5. sorted+Comparator 排序

工作中，排序的需求比较多，使用sorted+Comparator排序，真的很香。

List<UserInfo>userInfoList=newArrayList<>();
userInfoList.add(newUserInfo(1L,"捡田螺的小男孩",18));
userInfoList.add(newUserInfo(3L,"捡瓶子的小男孩",26));
userInfoList.add(newUserInfo(2L,"程序员田螺",27));

/**
*sorted+Comparator.comparing排序列表，
*/
userInfoList=userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList());
userInfoList.forEach(a->System.out.println(a.toString()));

System.out.println("开始降序排序");

/**
*如果想降序排序，则可以使用加reversed()
*/
userInfoList=userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()).collect(Collectors.toList());
userInfoList.forEach(a->System.out.println(a.toString()));

运行结果

UserInfo{userId=1, userName='捡田螺的小男孩', age=18}
UserInfo{userId=3, userName='捡瓶子的小男孩', age=26}
UserInfo{userId=2, userName='程序员田螺', age=27}
开始降序排序
UserInfo{userId=2, userName='程序员田螺', age=27}
UserInfo{userId=3, userName='捡瓶子的小男孩', age=26}
UserInfo{userId=1, userName='捡田螺的小男孩', age=18}

6.distinct去重

distinct可以去除重复的元素:

List<String>list=Arrays.asList("A","B","F","A","C");
List<String>temp=list.stream().distinct().collect(Collectors.toList());
temp.forEach(System.out::println);

7. findFirst 返回第一个

findFirst 很多业务场景，我们只需要返回集合的第一个元素即可：

List<String>list=Arrays.asList("A","B","F","A","C");
list.stream().findFirst().ifPresent(System.out::println);

8. anyMatch是否至少匹配一个元素

anyMatch&nbs编程p;检查流是否包含至少一个满足给定谓词的元素。

Stream<String>stream=Stream.of("A","B","C","D");
booleanmatch=stream.anyMatch(s->s.contains("C"));
System.out.println(match);

输出

true

9. allMatch 匹配所有元素

allMatch 检查流是否所有都满足给定谓词的元素。

Stream<String>stream=Stream.of("A","B","C","D");
booleanmatch=stream.allMatch(s->s.contains("C"));
System.out.println(match);

输出

false

10. map转换

map方法可以帮我们做元素转换，比如一个元素所有字母转化为大写，又或者把获取一个元素对象的某个属性，demo如下：

List<String>list=Arrays.asList("jay","tianluo");
//转化为大写
List<String>upperCaselist=list.stream().map(String::toUpperCase).collect(Collectors.toList());
upperCaselist.forEach(System.out::println);

11. Reduce

Reduce可以合并流的元素，并生成一个值

intsum=Stream.of(1,2,3,4).reduce(0,(a,b)->a+b);
System.out.println(sum);

12. peek 打印个日志

peek()方法是一个中间Stream操作，有时候我们可以使用peek来打印日志。

List<String>result=Stream.of("程序员田螺","捡田螺的小男孩","捡瓶子的小男孩")
.filter(a->a.contains("田螺"))
.peek(a->System.out.println("关注公众号:"+a)).collect(Collectors.toList());
System.out.println(result);

运行结果

关注公众号:程序员田螺
关注公众号:捡田螺的小男孩
[程序员田螺, 捡田螺的小男孩]

13. Max，Min最大最小

使用lambda流求最大，最小值，非常方便。

List<UserInfo>userInfoList=newArrayList<>();
userInfoList.add(newUserInfo(1L,"捡田螺的小男孩",18));
userInfoList.add(newUserInfo(3L,"捡瓶子的小男孩",26));
userInfoList.add(newUserInfo(2L,"程序员田螺",27));

Optional<UserInfo>maxAgeUserInfoOpt=userInfoList.stream().max(Comparator.comparing(UserInfo::getAge));
maxAgeUserInfoOpt.ifPresent(userInfo->System.out.println("maxage user:"+userInfo));

Optional<UserInfo>minAgeUserInfoOpt=userInfoList.stream().min(Comparator.comparing(UserInfo::getAge));
minAgeUserInfoOpt.ifPresent(userInfo->System.out.println("minage user:"+userInfo));

运行结果

max age user:UserInfo{userId=2, userName='程序员田螺', age=27}
min age user:UserInfo{userId=1, userName='捡田螺的小男孩', age=18}

14. count统计

一般count()表示获取流数据元素总数。

List<UserInfo>userInfoList=newArrayList<>();
userInfoList.add(newUserInfo(1L,"捡田螺的小男孩",18));
userInfoList.add(newUserInfo(3L,"捡瓶子的小男孩",26));
userInfoList.add(newUserInfo(2L,"程序员田螺",27));

longcount=userInfoList.stream().filter(user->user.getAge()>18).count();
System.out.println("大于18岁的用户:"+count);

输出

大于18岁的用户:2

15. 常用函数式接口

其实lambda离不开函数式接口，我们来看下JDK8常用的几个函数式接口：

Function<T, R>（转换型）: 接受一个输入参数，返回一个结果
Consumer<T> （消费型）: 接收一个输入参数，并且无返回操作
Predicate<T> （判断型）: 接收一个输入参数，并且返回布尔值结果
Supplier<T> （供给型）: 无参数，返回结果

Function<T, R> 是一个功能转换型的接口，可以把将一种类型的数据转化为另外一种类型的数据

privatevoidtestFunction(){
//获取每个字符串的长度，并且返回
Function<String,Integer>function=String::length;
Stream<String>stream=Stream.of("程序员田螺","捡田螺的小男孩","捡瓶子的小男孩");
Stream<Integer>resultStream=stream.map(function);
resultStream.forEach(System.out::println);
}

Consumer<T>是一个消费性接口，通过传入参数，并且无返回的操作

privatevoidtestComsumer(){
//获取每个字符串的长度，并且返回
Consumer<String>comsumer=System.out::println;
Stream<String>stream=Stream.of("程序员田螺","捡田螺的小男孩","捡瓶子的小男孩");
stream.forEach(comsumer);
}

Predicate<T>是一个判断型接口,并且返回布尔值结果.

privatevoidtestPredicate(){
//获取每个字符串的长度，并且返回
Predicate<Integer>predicate=a->a>18;
UserInfouserInfo=newUserInfo(2L,"程序员田螺",27);
System.out.println(predicate.test(userInfo.getAge()));
}

Supplier<T>是一个供给型接口,无参数，有返回结果。

privatevoidtestSupplier(){
Supplier<Integer>supplier=()->Integer.valueOf("666");
System.out.println(supplier.get());
}

这几个函数在日常开发中，也是可以灵活应用的，比如我们DAO操作完数据库，是会有个result的整型结果返回。我们就可以用Supplier<T>来统一判断是否操作成功。如下：

privatevoidsaveDb(Supplier<Integer>supplier){
if(supplier.get()>0){
System.out.println("插入数据库成功");
}else{
System.out.println("插入数据库失败");
}
}

@Test
publicvoidadd()throwsException{
Coursecourse=newCourse();
course.setCname("java");
course.setUserId(100L);
course.setCstatus("Normal");
saveDb(()->courseMapper.insert(course));
}

到此这篇关于简单聊聊工作中常用的Java Lambda表达式的文章就介绍到这了,更多相关Java Lambda表达式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

相关文章 大家在看