常用Lambda表达式


前言,我们日常工作中,Lambda 使用比较多的场景,就是集合类下的 Lambda 流操作,往往几行代码可以帮助我们实现复杂代码,接下来我们把 Lambda 流的常用方法用案列讲解一下。,ForEach,集合的遍历 forEach 方法:,Collect,将操作后的对象转化为新的对象:,Filter,Filter 为过滤的意思,只要满足 Filter 表达式的数据就可以留下来,不满足的数据被过滤掉。,Map,map 方法可以让我们进行一些流的转化,比如原来流中的元素是 A,通过 map 操作,可以使返回的流中的元素是 B。,MapToInt,mapToInt 方法的功能和 map 方法一样,只不过 mapToInt 返回的结果已经没有泛型,已经明确是 int 类型的流了。,源码如下:,Distinct,distinct 方法有去重的功能:,Sorted,Sorted 方法提供了排序的功能,并且允许我们自定义排序。,groupingBy,groupingBy 是能够根据字段进行分组,toMap 是把 List 的数据格式转化成 Map 的格式。,FindFirst,findFirst 表示匹配到第一个满足条件的值就返回:,Reduce,reduce 方法允许我们在循环里面叠加计算值:,Peek,peek 方法很简单,我们在 peek 方法里面做任意没有返回值的事情,比如打印日志:,Limit,limit 方法会限制输出值个数,入参是限制的个数大小:,Max,Min,通过 max、min 方法,可以获取集合中最大、最小的对象。,总结,本文我们介绍十几种 Lambda 表达式常用的方法,懂这些,这样你在工作中遇到复杂数据结构转化时,肯定会得心应手了。,

前言

我们日常工作中,Lambda 使用比较多的场景,就是集合类下的 Lambda 流操作,往往几行代码可以帮助我们实现复杂代码,接下来我们把 Lambda 流的常用方法用案列讲解一下。

ForEach

集合的遍历 forEach 方法:

public void testForEach(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("3");         }};         list.forEach(s-> System.out.println(s));     } 
  
 

Collect

将操作后的对象转化为新的对象:

public void testCollect(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("2");         }};         //转换为新的list         List newList = list.stream().map(s -> Integer.valueOf(s)).collect(Collectors.toList());     } 
  
 

Filter

Filter 为过滤的意思,只要满足 Filter 表达式的数据就可以留下来,不满足的数据被过滤掉。

public void testFilter() {
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("3");         }};                 list.stream()                 // 过滤掉我们希望留下来的值                 // 表示我们希望字符串是 1 能留下来                 // 其他的过滤掉                 .filter(str -> "1".equals(str))                 .collect(Collectors.toList());     } 
  
 

Map

map 方法可以让我们进行一些流的转化,比如原来流中的元素是 A,通过 map 操作,可以使返回的流中的元素是 B。

public void testMap() {
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("3");         }};         //通过 map 方法list中元素转化成 小写         List
   
     strLowerList = list.stream()                 .map(str -> str.toLowerCase())                 .collect(Collectors.toList());     } 
   
  
 

MapToInt

mapToInt 方法的功能和 map 方法一样,只不过 mapToInt 返回的结果已经没有泛型,已经明确是 int 类型的流了。

源码如下:

public void testMapToInt() {
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("3");         }};         list.stream()                 .mapToInt(s->Integer.valueOf(s))                 // 一定要有 mapToObj,因为 mapToInt 返回的是 IntStream,因为已经确定是 int 类型了                 // 所有没有泛型的,而 Collectors.toList() 强制要求有泛型的流,所以需要使用 mapToObj                 // 方法返回有泛型的流                 .mapToObj(s->s)                 .collect(Collectors.toList());         list.stream()                 .mapToDouble(s->Double.valueOf(s))                 // DoubleStream/IntStream 有许多 sum(求和)、min(求最小值)、max(求最大值)、average(求平均值)等方法                 .sum();     } 
  
 

Distinct

distinct 方法有去重的功能:

public void testDistinct(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("2");         }};         list.stream()                 .map(s -> Integer.valueOf(s))                 .distinct()                 .collect(Collectors.toList());     } 
  
 

Sorted

Sorted 方法提供了排序的功能,并且允许我们自定义排序。

public void testSorted(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("3");         }};         list.stream()                 .map(s -> Integer.valueOf(s))                 // 等同于 .sorted(Comparator.naturalOrder()) 自然排序                 .sorted()                 .collect(Collectors.toList());         // 自定义排序器         list.stream()                 .map(s -> Integer.valueOf(s))                 // 反自然排序                 .sorted(Comparator.reverseOrder())                 .collect(Collectors.toList());     } 
  
 

groupingBy

groupingBy 是能够根据字段进行分组,toMap 是把 List 的数据格式转化成 Map 的格式。

public void testGroupBy(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("2");         }};         Map
   
    > strList = list.stream().collect(Collectors.groupingBy(s -> {             if("2".equals(s)) {                 return "2";             }else {                 return "1";             }         }));     } 
   
  
 

FindFirst

findFirst 表示匹配到第一个满足条件的值就返回:

public void testFindFirst(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("2");         }};         list.stream()                 .filter(s->"2".equals(s))                 .findFirst()                 .get();         // 防止空指针         list.stream()                 .filter(s->"2".equals(s))                 .findFirst()                 // orElse 表示如果 findFirst 返回 null 的话,就返回 orElse 里的内容                 .orElse("3");         Optional
   
     str= list.stream()                 .filter(s->"2".equals(s))                 .findFirst();         // isPresent 为 true 的话,表示 value != null         if(str.isPresent()){             return;         }     } 
   
  
 

Reduce

reduce 方法允许我们在循环里面叠加计算值:

public void testReduce(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("3");         }};         list.stream()                 .map(s -> Integer.valueOf(s))                 // s1 和 s2 表示循环中的前后两个数                 .reduce((s1,s2) -> s1+s2)                 .orElse(0);         list.stream()                 .map(s -> Integer.valueOf(s))                 // 第一个参数表示基数,会从 100 开始加                 .reduce(100,(s1,s2) -> s1+s2);     } 
  
 

Peek

peek 方法很简单,我们在 peek 方法里面做任意没有返回值的事情,比如打印日志:

public void testPeek(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("3");         }};         list.stream().map(s -> Integer.valueOf(s))                 .peek(s -> System.out.println(s))                 .collect(Collectors.toList());     } 
  
 

Limit

limit 方法会限制输出值个数,入参是限制的个数大小:

public void testLimit(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("3");         }};         list.stream()                 .map(s -> Integer.valueOf(s))                 .limit(2L)                 .collect(Collectors.toList());     } 
  
 

Max,Min

通过 max、min 方法,可以获取集合中最大、最小的对象。

public void testMaxMin(){
        List
 
   list = new ArrayList
  
   () {
   {             add("1");             add("2");             add("2");         }};         list.stream().max(Comparator.comparing(s -> Integer.valueOf(s))).get();         list.stream().min(Comparator.comparing(s -> Integer.valueOf(s))).get();     } 
  
 

总结

本文我们介绍十几种 Lambda 表达式常用的方法,懂这些,这样你在工作中遇到复杂数据结构转化时,肯定会得心应手了。

,前言

上一篇:linux rocketmq 安装

下一篇:BeanUtils.copyProperties的用法


蚂蚁钢琴网 2008-2025 somall.com.cn 皖ICP备2023010105号
大写数字 热点城市 热点地区 热点街道 热点时间 房贷计算器
钢琴调律 钢琴调音 钢琴调律价格
温馨提示:部分文章图片数据来源与网络,仅供参考!版权归原作者所有,如有侵权请联系删除!
违法和不良信息24小时举报热线:18056540210