java8 新特性Stream流的應用_ZenDei技術網路在線

作為一個合格的程式員，如何讓代碼更簡潔明瞭，提升編碼速度尼。今天跟著我一起來學習下java 8 stream 流的應用吧。廢話不多說，直入正題。考慮以下業務場景，有四個人員信息，我們需要根據性別統計人員的姓名。 package com; import java.util.ArrayList; ...

作為一個合格的程式員，如何讓代碼更簡潔明瞭，提升編碼速度尼。

今天跟著我一起來學習下java 8 stream 流的應用吧。

廢話不多說，直入正題。

考慮以下業務場景，有四個人員信息，我們需要根據性別統計人員的姓名。

package com;

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

public class Test {
    public static void main(String[] args) {

        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        map.put("userName", "張三");
        map.put("age", "18");
        map.put("sex", "男");
        list.add(map);

        Map<String, String> map1 = new HashMap<>();
        map1.put("userName", "李四");
        map1.put("age", "20");
        map1.put("sex", "女");
        list.add(map1);

        Map<String, String> map2 = new HashMap<>();
        map2.put("userName", "王五");
        map2.put("age", "15");
        map2.put("sex", "女");
        list.add(map2);

        Map<String, String> map3 = new HashMap<>();
        map3.put("userName", "若風");
        map3.put("age", "23");
        map3.put("sex", "男");
        list.add(map3);

        //現在我們要根據性別統計人員的姓名
        //初級寫法
        StringBuilder stringBuilder1 = new StringBuilder();
        StringBuilder stringBuilder2 = new StringBuilder();
        for (Map<String, String> item : list) {
            //指向當前下標的map
            System.out.println("item: " + item);
            if (item.get("sex").equals("男")) {
                //存性別為男的人員名稱，以逗號隔開
                stringBuilder1.append(item.get("userName")).append(",");
            } else {
                //存性別為女的人員名稱，以逗號隔開
                stringBuilder2.append(item.get("userName")).append(",");
            }
        }
        //去掉最後一個逗號
        String userName_nan = stringBuilder1.deleteCharAt(stringBuilder1.length() - 1).toString();
        String userName_nv = stringBuilder2.deleteCharAt(stringBuilder2.length() - 1).toString();
        System.out.println("userName_nan: " + userName_nan);
        System.out.println("userName_nv: " + userName_nv);
    }
}

列印記錄如下：

是不是感覺代碼寫的不怎麼優雅，那麼我們開始換個姿勢，用java8 Stream 流的方式來操作。

package com;

import org.apache.commons.lang.StringUtils;

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

public class Test {
    public static void main(String[] args) {

        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        map.put("userName", "張三");
        map.put("age", "18");
        map.put("sex", "男");
        list.add(map);

        Map<String, String> map1 = new HashMap<>();
        map1.put("userName", "李四");
        map1.put("age", "20");
        map1.put("sex", "女");
        list.add(map1);

        Map<String, String> map2 = new HashMap<>();
        map2.put("userName", "王五");
        map2.put("age", "15");
        map2.put("sex", "女");
        list.add(map2);

        Map<String, String> map3 = new HashMap<>();
        map3.put("userName", "若風");
        map3.put("age", "23");
        map3.put("sex", "男");
        list.add(map3);

        //現在我們要根據性別統計人員的姓名
        //初級寫法
//        StringBuilder stringBuilder1 = new StringBuilder();
//        StringBuilder stringBuilder2 = new StringBuilder();
//        for (Map<String, String> item : list) {
//            //指向當前下標的map
//            System.out.println("item: " + item);
//            if (item.get("sex").equals("男")) {
//                //存性別為男的人員名稱，以逗號隔開
//                stringBuilder1.append(item.get("userName")).append(",");
//            } else {
//                //存性別為女的人員名稱，以逗號隔開
//                stringBuilder2.append(item.get("userName")).append(",");
//            }
//        }
//        //去掉最後一個逗號
//        String userName_nan = stringBuilder1.deleteCharAt(stringBuilder1.length() - 1).toString();
//        String userName_nv = stringBuilder2.deleteCharAt(stringBuilder2.length() - 1).toString();
//        System.out.println("userName_nan: " + userName_nan);
//        System.out.println("userName_nv: " + userName_nv);

        //java8  stream流的寫法
        //先定義一個Map 用來存儲我們的人員姓名
        Map<String, String> userNameMap = new HashMap<>(4);
        //裝逼開始
        //
        list.stream().map(v1 -> {
            //map 可以理解為new 一個新的對象，複製原來list的數據copy 到一個新的List ，用map對數據進行修改操作時，不會改變原來的對象。需要返回值！！！
            //v1指向當前下標的map對象
            System.out.println("v1: " + v1);
            //定義一個新的map 用來存儲人員的姓名和性別
            Map<String, String> data = new HashMap<>();
            map.put("userName", v1.get("userName"));
            map.put("sex", v1.get("sex"));
            return map;
        }).reduce(userNameMap, (a, b) -> {
            //a 可以理解為上一次迴圈的返回結果
            //b 當前的迴圈對象
            //取出當前迴圈的人員姓名　
            String thisUserName = b.get("userName");
            //取出當前迴圈的人員性別
            String thisSex = b.get("sex");
            if (thisSex.equals("男")) {
                //取上一次迴圈的返回結果，第一次迴圈，是沒有值的，第二次迴圈時，取得是第一次迴圈的返回結果，以此類推。
                String val = a.get("newMenUserName");
                System.out.println("val: " + val);
                //第一次迴圈時val 是沒有值的，我們賦值一個空的字元串，
                // 第二次迴圈時，把第一次迴圈的返回的newUserName的值取出來，加上逗號，拼接當前下標的人員姓名
                String newUserName = (StringUtils.isBlank(val) ? StringUtils.EMPTY : val + ",") + thisUserName;
                //把拼接好的人員姓名添加到map 中
                System.out.println("newUserName: " + newUserName);
                a.put("newMenUserName", newUserName);
            } else {
                //取上一次迴圈的返回結果，第一次迴圈，是沒有值的，第二次迴圈時，取得是第一次迴圈的返回結果，以此類推。
                String val = a.get("newWomenUserName");
                System.out.println("val: " + val);
                //第一次迴圈時val 是沒有值的，我們賦值一個空的字元串，
                // 第二次迴圈時，把第一次迴圈的返回的newUserName的值取出來，加上逗號，拼接當前下標的人員姓名
                String newUserName = (StringUtils.isBlank(val) ? StringUtils.EMPTY : val + ",") + thisUserName;
                System.out.println("newUserName: " + newUserName);
                //把拼接好的人員姓名添加到map 中
                a.put("newWomenUserName", newUserName);
            }
            //返回當前迴圈的map
            return a;
        });
        System.out.println("userNameMap: " + userNameMap);
        System.out.println("userName_nan: " + userNameMap.get("newMenUserName"));
        System.out.println("userName_nv: " + userNameMap.get("newWomenUserName"));

    }
}

列印的值如下：

場景二、取兩個List 的交集

package com;

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

public class Test {
    public static void main(String[] args) {

//        業務場景2：取出兩個List 的數值相同的元素（交集）
        List<Integer> list1=new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        List<Integer> list2=new ArrayList<>();
        list2.add(2);
        list2.add(4);
        //交集
        List<Integer> list3=new ArrayList<>();
        //初級寫法
        for(Integer item:list1){
            if(list2.contains(item)){
                list3.add(item);
            }
        }
        System.out.println("for迴圈的結果");
        System.out.println("list3: "+list3);

        System.out.println("------------------------------------------------------------");

        //stream 流的寫法
        //v1 表示當前下標的對象
        //filter  過濾掉結果為false 的數據
        list3=list1.stream().filter(v1->list2.contains(v1)).collect(Collectors.toList());
        System.out.println("stream迴圈的結果");
        System.out.println("list3: "+list3);

        //list 本身的方法
        System.out.println("------------------------------------------------------------");
        System.out.println("old 數據，list1："+list1);
        System.out.println("old 數據，list2："+list2);
        list1.retainAll(list2);
        System.out.println("new 數據，list1"+list1);
        System.out.println("new 數據，list2"+list2);
    }
}

列印結果：

場景三、對一個List 排序

package com;

import java.util.*;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {

//        業務場景3：對List 排序
        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        map.put("userName", "張三");
        map.put("age", "18");
        map.put("sex", "男");
        list.add(map);

        Map<String, String> map1 = new HashMap<>();
        map1.put("userName", "李四");
        map1.put("age", "20");
        map1.put("sex", "女");
        list.add(map1);

        Map<String, String> map2 = new HashMap<>();
        map2.put("userName", "王五");
        map2.put("age", "15");
        map2.put("sex", "女");
        list.add(map2);

        Map<String, String> map3 = new HashMap<>();
        map3.put("userName", "若風");
        map3.put("age", "23");
        map3.put("sex", "男");
        list.add(map3);


        //stream 流的寫法
        System.out.println("------------------------排序前--------------------------------");
        System.out.println("排序前,List :"+list);
        //sorted stream排序,這裡我們根據年齡和姓名進行排序
        //Test::age Java 8 中我們可以通過 `::` 關鍵字來訪問類的構造方法，對象方法，靜態方法。
        //裝逼開始
        List<Map<String, String>> list2=list.stream().sorted(Comparator.comparing(Test::age).thenComparing(Comparator.comparing(Test::userName))).collect(Collectors.toList());
        System.out.println();
        System.out.println("------------------------排序後--------------------------------");
        System.out.println("排序後,list2 :"+list2);
    }
    private static String userName(Map<String,String> map){
        return map.get("userName");
    }
    private static Integer age(Map<String,String> map){
        return Integer.parseInt(map.get("age"));
    }
}

列印結果：

總結：

   1、 Stream流不是一種數據結構，不保存數據，它只是在原數據集上定義了一組操作。
   2、這些操作是惰性的，即每當訪問到流中的一個元素，才會在此元素上執行這一系列操作。
   3、Stream不保存數據，故每個Stream流只能使用一次。 Stream流可以分成兩部分：Intermediate(中間操作)和Terminal(終止操作)。中間操作的返回結果都是Stream，故可以多個中間操作疊加；終止操作用於返回我們最終需要的數據，只能有一個終止操作！！！一、stream流的Intermediate方法(中間操作)
1、filter(Predicate)
    將結果為false的元素過濾掉，不會改變原來對象的數據，需要顯示指定返回值！！！
2、map(fun)
   把對象copy到一個新的對象中，遍歷新的對象，對數據進行修改不會改變原來對象的數據，需要顯示指定返回值！！！
3、flatMap(fun)
    若元素是流，將流攤平為正常元素，再進行元素轉換
4、limit(n)
    保留前n個元素
5、 skip(n)
    跳過前n個元素
6、distinct()
    剔除重覆元素
7、sorted(Comparator)
    將流元素按Comparator排序
8、peek(fun)
    流不變，但會把每個元素傳入fun執行，可以用作調試
9、forEach()
    遍歷當前對象，對數據進行修改時，會改變對象的數據，不需要顯示指定返回值！！！（註意和map的區別）二、stream流的Terminal方法(終結操作)
    約簡操作 1、max(Comparator)
        取最大值
2、min(Comparator)
        取最小值
3、 count()
        去和
4、findFirst()
        返回第一個元素
5、 findAny()
        返回任意元素
6、anyMatch(Predicate)
        任意元素匹配時返回true
7、allMatch(Predicate)
        所有元素匹配時返回true
8、noneMatch(Predicate)
        沒有元素匹配時返回true
9、reduce(fun)
        從流中計算某個值，接受一個二元函數作為累積器，從前兩個元素開始持續應用它，累積器的中間結果作為第一個參數，流元素作為第二個參數
10、 reduce(a, fun)
        a為么元值，作為累積器的起點
11、reduce(a, fun1, fun2)
        與二元變形類似，併發操作中，當累積器的第一個參數與第二個參數都為流元素類型時，可以對各個中間結果也應用累積器進行合併，但是當累積器的第一個參數不是流元素類型而是類型T的時候，各個中間結果也為類型T，需要fun2來將各個中間結果進行合併（參考場景一）
三、stream流的收集操作：
1、Collectors.toList() 返回一個List
2、Collectors.toSet() 返回一個集合
3、Collectors.toCollection(集合的構造器引用)
4、Collectors.joining()、Collectors.joining(delimiter)、Collectors.joining(delimiter、prefix、suffix)
字元串元素連接
5、Collectors.summarizingInt/Long/Double(ToInt/Long/DoubleFunction)
產生Int/Long/DoubleSummaryStatistics對象，它有getCount、getSum、getMax、getMin方法，註意在沒有元素時，getMax和getMin返回Integer/Long/Double.MAX/MIN_VALUE
6、Collectors.toMap(fun1, fun2)/toConcurrentMap
兩個fun用來產生鍵和值，若值為元素本身，則fun2為Function.identity()
7、Collectors.toMap(fun1, fun2, fun3)/toConcurrentMap
fun3用於解決鍵衝突，例如(oldValue, newValue) -> oldValue，有衝突時保留原值
8、Collectors.toMap(fun1, fun2, fun3, fun4)/toConcurrentMap
預設返回HashMap或ConcurrentHashMap，fun4可以指定返回的Map類型，為對應的構造器引元
9、Collectors.groupingBy(fun)/groupingByConcurrent(fun)
fun是分類函數，生成Map，鍵是fun函數結果，值是具有相同fun函數結果元素的列表
10、Collectors.partitioningBy(fun)
鍵是true/false，當fun是斷言函數時用此方法，比groupingBy(fun)更高效
11、Collectors.groupingBy(fun1, fun2)
fun2為下游收集器，可以將列表轉換成其他形式，例如toSet()、counting()、summingInt/Long/Double(fun)、maxBy(Comparator)、minBy(Comparator)、mapping(fun1, fun2)(fun1為轉換函數，fun2為下游收集器)

參考: https://blog.csdn.net/lixiaobuaa/article/details/81099838 本博客僅作為學習參考