常用的Lambda表达式案例解析，工作中都会用到！

雨点打透心脏的1/2处 2023-09-30 16:55 23阅读 0赞

## 前言 ##

文章首发在公众号（月伴飞鱼），之后同步到个人网站：[xiaoflyfish.cn/][xiaoflyfish.cn]

**觉得有收获，希望帮忙点赞，转发下哈，谢谢，谢谢**

我们日常工作中，Lambda 使用比较多的场景，就是集合类下的 Lambda 流操作，往往几行代码可以帮助我们实现复杂代码

接下来我们把 Lambda 流的常用方法用案列讲解一下。

## ForEach ##

集合的遍历forEach方法

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

## Collect ##

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

public void testCollect(){
            List<String> list = new ArrayList<String>() {
       {
                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<String> list = new ArrayList<String>() {
       {
                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<String> list = new ArrayList<String>() {
       {
                add("1");
                add("2");
                add("3");
            }};
            //通过 map 方法list中元素转化成 小写
            List<String> strLowerList = list.stream()
                    .map(str -> str.toLowerCase())
                    .collect(Collectors.toList());
        }
    复制代码

## MapToInt ##

mapToInt 方法的功能和 map 方法一样，只不过 mapToInt 返回的结果已经没有泛型，已经明确是 int 类型的流了，源码如下：

public void testMapToInt() {
            List<String> list = new ArrayList<String>() {
       {
                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<String> list = new ArrayList<String>() {
       {
                add("1");
                add("2");
                add("2");
            }};
            list.stream()
                    .map(s -> Integer.valueOf(s))
                    .distinct()
                    .collect(Collectors.toList());
        }
    复制代码

## Sorted ##

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

public void testSorted(){
            List<String> list = new ArrayList<String>() {
       {
                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<String> list = new ArrayList<String>() {
       {
                add("1");
                add("2");
                add("2");
            }};
    
            Map<String, List<String>> strList = list.stream().collect(Collectors.groupingBy(s -> {
                if("2".equals(s)) {
                    return "2";
                }else {
                    return "1";
                }
            }));
        }
    复制代码

## FindFirst ##

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

public void testFindFirst(){
            List<String> list = new ArrayList<String>() {
       {
                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<String> str= list.stream()
                    .filter(s->"2".equals(s))
                    .findFirst();
            // isPresent 为 true 的话，表示 value != null
            if(str.isPresent()){
                return;
            }
        }
    复制代码

## Reduce ##

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

public void testReduce(){
            List<String> list = new ArrayList<String>() {
       {
                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<String> list = new ArrayList<String>() {
       {
                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<String> list = new ArrayList<String>() {
       {
                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<String> list = new ArrayList<String>() {
       {
                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 表达式常用的方法

懂这些，这样你在工作中遇到复杂数据结构转化时，肯定会得心应手了。

## 最后 ##

欢迎关注公众号：月伴飞鱼

> 每天分享一篇实用的技术文章，对面试，工作都有帮助

[xiaoflyfish.cn]: https://link.juejin.cn?target=https%3A%2F%2Fxiaoflyfish.cn%2F