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

前言

公衆号（月伴飛魚），之後同步到個人網站：​​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      

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中元素轉化成 小寫      

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（求平均值）等方法      

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))
                // 反自然排序      

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 表達式常用的方法

懂這些，這樣你在工作中遇到複雜資料結構轉化時，肯定會得心應手了。

最後