Java8中你可能不知道的一些地方之Stream實戰

時間 2020-08-12

標籤 java8 java 可能不知道一些地方 stream 實戰欄目 Java 简体版

原文原文鏈接

提及流，咱們會想起手機，電腦組裝流水線，物流倉庫商品包裝流水線等等。若是把手機 ,電腦,包裹看作最終結果的話,那麼加工商品前的各類零部件就能夠看作數據源，而中間一系列的加工做業操做，就能夠看作流的處理。java

流的概念

Java Se中對於流的操做有輸入輸出IO流,而Java8中引入的Stream 屬於Java API中的一個新成員，它容許你以聲明性方式處理數據集合，Stream 使用一種相似 SQL 語句從數據庫查詢數據的直觀方式來提供一種對 Java 集合運算和表達的高階抽象。注意這裏的流操做能夠看作是對集合數據的處理。sql

簡單來講,流是一種數據渠道,用於操做數據源(集合、數組、文件等)所生產的元素序列。數據庫

源-流會使用一個提供數據的源,如集合、數組或輸入|輸出資源。

從有序集生成流時會保留原有的順序。由列表生成的流，其元素順序與列表一致編程

元素序列-就像集合同樣，流也提供了一個接口,能夠訪問特定元素類型的一組有序值。
數據處理操做-流的數據處理功能支持相似於數據庫的操做(數據篩選、過濾、排序等操做)。
流水線-多個流操做自己會返回一個流，多個操做就能夠連接起來,成爲數據處理的一道流水線。

流&集合

計算的時期

集合中數據都是計算完畢的數據，例如從數據庫中查詢用戶記錄按用戶id 查詢降序排列而後經過list 接收用戶記錄，數據的計算已在放入集合前完成。數組

流中數據按需計算，按照使用者的須要計算數據，例如經過搜索引擎進行搜索，搜索出來的條目並非所有呈現出來的，並且先顯示最符合的前 10 條或者前 20 條，只有在點擊「下一頁」的時候，纔會再輸出新的 10 條。流的計算也是這樣，當用戶須要對應數據時，Stream 纔會對其進行計算處理。dom

外部迭代與內部迭代

把集合比做一個工廠的倉庫的話，一開始工廠硬件比較落後，要對貨物做什麼修改，此時工人親自走進倉庫對貨物進行處理，有時候還要將處理後的貨物轉運到另外一個倉庫中。此時對於開發者來講須要親自去作迭代，一個個地找到須要的貨物，並進行處理，這叫作外部迭代。ide

當工廠發展起來後，配備了流水線做業，工廠只要根據需求設計出相應的流水線，而後工人只要把貨物放到流水線上，就能夠等着接收成果了，並且流水線還能夠根據要求直接把貨物輸送到相應的倉庫。函數式編程

這就叫作內部迭代，流水線已經幫你把迭代給完成了，你只須要說要幹什麼就能夠了（即設計出合理的流水線）。至關於 Java8 引入的Stream 對數據的處理實現了」自動化」操做。函數

流操做過程

整個流操做就是一條流水線，將元素放在流水線上一個個地進行處理。須要注意的是:不少流操做自己就會返回一個流，因此多個操做能夠直接鏈接起來，以下圖這樣，操做能夠進行鏈式調用，而且並行流還能夠實現數據流並行處理操做。性能

總的來講，流操做過程分爲三個階段:

建立

藉助數據源建立流對象

中間處理

篩選、切片、映射、排序等中間操做

終止流

匹配、彙總、分組等終止操做

流的建立

對流操做首先要建立對應的流，流的建立集中形式以下:

1 集合建立流

在 Java 8 中, 集合接口有兩個方法來生成流：

stream() − 爲集合建立串行流。
parallelStream() − 爲集合建立並行流。

示例代碼以下:

public static void main(String[] args) {
    /**
         * 定義集合l1 併爲集合建立串行流
         */
    List<String> l1 = Arrays.asList("周星馳", "周杰倫", "周星星", "周潤發");
    // 返回串行流
    l1.stream();
    // 返回並行流
    l1.parallelStream();
}

上述操做獲得的流是經過原始數據轉換過來的流，除了這種流建立的基本操做外，對於流的建立還有如下幾種方式。

2 值建立流

Stream.of(T...) ： Stream.of("aa", "bb") 生成流

//值建立流 生成一個字符串流
Stream<String> stream = Stream.of("java8", "Spring", "SpringCloud");
stream.forEach(System.out::println);

3 數組建立流

根據參數的數組類型建立對應的流。

Arrays.stream(T[ ])
Arrays.stream(int[ ])
Arrays.stream(double[ ])
Arrays.stream(long[ ])

/**
 * 這裏以int 爲例   long double 再也不舉例
 */
 Stream stream = Arrays.stream(Arrays.asList(10, 20, 30, 40).toArray());
 // 根據數組索引範圍建立指定Stream
 stream = Arrays.stream(Arrays.asList(10, 20, 30, 40).toArray(), 0, 2);

4 文件生成流

stream = Files.lines(Paths.get("C:\\java\\jdbc.properties"));
System.out.println(stream.collect(Collectors.toList()));
// 指定字符集編碼
stream = Files.lines(Paths.get("C:\\java\\jdbc.properties"), Charset.forName("utf-8"));
System.out.println(stream.collect(Collectors.toList()));

5 函數生成流

兩個方法：

iterate ：依次對每一個新生成的值應用函數
generate ：接受一個函數，生成一個新的值

// 重100 開始 生成偶數流
 Stream.iterate(100, n -> n + 2);
 // 產生1-100 隨機數
 Stream.generate(() ->(int) (Math.random() * 100 + 1));

流中間操做

流的中間操做分爲三大類:篩選切片、映射、排序。

篩選切片:相似sql 中where 條件判斷的意思，對元素進行篩選操做

映射:對元素結果進行轉換，優勢相似select 字段意思或者對元素內容進行轉換處理

排序:比較好理解，經常使用sql 中按字段升序降序操做

流中間操做數據準備（這裏以訂單數據處理爲例）

@Data
public class Order {
    // 訂單id
    private Integer id;
    // 訂單用戶id
    private Integer userId;
    // 訂單編號
    private String orderNo;
    // 訂單日期
    private Date orderDate;
    // 收貨地址
    private String address;
    // 建立時間
    private Date createDate;
    // 更新時間
    private Date updateDate;
    // 訂單狀態  0-未支付  1-已支付  2-待發貨  3-已發貨  4-已接收  5-已完成
    private Integer status;
    // 是否有效  1-有效訂單  0-無效訂單
    private Integer isValid;
    //訂單總金額
    private  Double total;
  }

Order order01 = new Order(1, 10, "20190301",
                new Date(), "上海市-浦東區", new Date(), new Date(), 4, 1, 100.0);
Order order02 = new Order(2, 30, "20190302",
                    new Date(), "北京市四惠區", new Date(), new Date(), 1, 1, 2000.0);
Order order03 = new Order(3, 20, "20190303",
                    new Date(), "北京市-朝陽區", new Date(), new Date(), 4, 1, 500.0);
Order order04 = new Order(4, 40, "20190304",
                    new Date(), "北京市-大興區", new Date(), new Date(), 4, 1, 256.0);
Order order05 = new Order(5, 40, "20190304",
                    new Date(), "上海市-松江區", new Date(), new Date(), 4, 1, 1000.0);
ordersList = Arrays.asList(order01, order02, order03, order04, order05);

篩選&切片

篩選有效訂單

// 過濾有效訂單
ordersList.stream().filter((order) -> order.getIsValid() == 1)
    .forEach(System.out::println);

篩選有效訂單取第一頁數據(每頁2條記錄)

// 過濾有效訂單 取第一頁數據(每頁2條記錄) 
 ordersList.stream().filter((order) -> order.getIsValid() == 1)
     .limit(2)
     .forEach(System.out::println);

篩選訂單集合有效訂單取最後一條記錄

// 過濾訂單集合有效訂單 取最後一條記錄
ordersList.stream().filter((order) -> order.getIsValid() == 1)
    .skip(ordersList.size() - 2)  // 跳過前ordersList.size()-2 記錄
    .forEach(System.out::println);

篩選有效訂單取第3頁數據(每頁2條記錄)

// 過濾有效訂單 取第3頁數據(每頁2條記錄) 並打印到控制檯
ordersList.stream().filter((order) -> order.getIsValid() == 1)
    .skip((3 - 1) * 2)
    .limit(2)
    .forEach(System.out::println);

篩選無效訂單去除重複訂單號記錄

// 過濾無效訂單 去除重複訂單號記錄  重寫Order equals 與 hashCode 方法
ordersList.stream().filter((order) -> order.getIsValid() == 0)
    .distinct()
    .forEach(System.out::println);

映射

過濾有效訂單,獲取全部訂單編號

//過濾有效訂單，獲取全部訂單編號
ordersList.stream().filter((order) -> order.getIsValid() == 1)
    .map((order) -> order.getOrderNo())
    .forEach(System.out::println);

過濾有效訂單 ,並分離每一個訂單下收貨地址市區信息

ordersList.stream().map(o -> o.getAddress()
    .split("-"))
    .flatMap(Arrays::stream)
    .forEach(System.out::println);

排序

過濾有效訂單根據用戶id 進行排序

//過濾有效訂單 根據用戶id 進行排序
ordersList.stream().filter((order) -> order.getIsValid() == 1)
    .sorted((o1, o2) -> o1.getUserId() - o2.getUserId())
    .forEach(System.out::println);  

 //或者等價寫法 
ordersList.stream().filter((order) -> order.getIsValid() == 1)
    .sorted(Comparator.comparingInt(Order::getUserId))
    .forEach(System.out::println);

過濾有效訂單 ,根據訂單狀態排序若是訂單狀態相同根據訂單建立時間排序

//過濾有效訂單  若是訂單狀態相同 根據訂單建立時間排序 反之根據訂單狀態排序
ordersList.stream().filter((order) -> order.getIsValid() == 1)
    .sorted((o1, o2) -> {
        if (o1.getStatus().equals(o2.getStatus())) {
            return o1.getCreateDate().compareTo(o2.getCreateDate());
        } else {
            return o1.getStatus().compareTo(o2.getStatus());
    }})
    .forEach(System.out::println);

// 等價形式
ordersList.stream().filter((order) -> order.getIsValid() == 1)
    .sorted(Comparator.comparing(Order::getCreateDate)
    .thenComparing(Comparator.comparing(Order::getStatus)))
    .forEach(System.out::println);

流的終止操做

終止操做會從流的流水線生成結果。其結果是任何不是流的值，好比常見的List、 Integer，甚至void等結果。對於流的終止操做，分爲如下三類:

查找與匹配

篩選有效訂單匹配是否所有爲已支付訂單

// 篩選有效訂單 匹配是否所有爲已支付訂單
System.out.println("allMatch匹配結果:" + 
                     ordersList.stream()
                        .filter((order) -> order.getIsValid() == 1)
                        .allMatch((o) -> o.getStatus() != 0)
                  );

篩選有效訂單匹配是否存在未支付訂單

// 篩選有效訂單 匹配是否存在未支付訂單
System.out.println("anyMatch匹配結果:" + 
                     ordersList.stream()
                        .filter((order) -> order.getIsValid() == 1)
                        .anyMatch((o) -> o.getStatus() == 0)
                  );

篩選有效訂單所有未完成訂單

// 篩選有效訂單 所有未完成訂單
System.out.println("noneMatch匹配結果:" + 
                    ordersList.stream()
                        .filter((order) -> order.getIsValid() == 1)
                        .noneMatch((o) -> o.getStatus() == 5)
                  );

篩選有效訂單返回第一條訂單

// 篩選有效訂單 返回第一條訂單
        System.out.println("findAny匹配結果:"+
                            ordersList.stream()
                                .filter((order) -> order.getIsValid() == 1)
                                .findAny()
                                 .get()
                          );

篩選全部有效訂單返回訂單總數

//  篩選全部有效訂單 返回訂單總數
        System.out.println("count結果:" + 
                            ordersList.stream()
                                .filter((order) -> order.getIsValid() == 1)
                                .count()
                        );

篩選有效訂單返回金額最大訂單金額

// 篩選有效訂單 返回金額最大訂單金額
        System.out.println("訂單金額最大值:" + 
                            ordersList.stream()
                                .filter((order) -> order.getIsValid() == 1)
                                .map(Order::getTotal)
                                .max(Double::compare)
                                .get()
                          );

篩選有效訂單返回金額最小訂單金額

// 篩選有效訂單 返回金額最小訂單金額
        System.out.println("訂單金額最小值:" + 
                                ordersList.stream()
                                    .filter((order) -> order.getIsValid() == 1)
                                    .map(Order::getTotal)
                                    .min(Double::compare)
                                    .get()
                          );

歸約&收集

1 歸約

將流中元素反覆結合起來，獲得一個值的操做

計算有效訂單總金額

// 計算有效訂單總金額
        System.out.println("有效訂單總金額:" + 
                            ordersList.stream()
                                .filter((order) -> order.getIsValid() == 1)
                                .map(Order::getTotal)
                                .reduce(Double::sum)
                                .get()
                          );

2 Collector數據收集

將流轉換爲其餘形式，coollect 方法做爲終端操做，接收一個Collector接口的實現，用於給Stream中元素作彙總的方法。最經常使用的方法，把流中全部元素收集到一個 List, Set 或 Collection中。

3 集合收集

經常使用集合收集方法 toList、toSet、toCollection、toMap等

篩選全部有效訂單並收集訂單列表

// 篩選全部有效訂單並收集訂單列表
ordersList.stream()
    .filter((order) -> order.getIsValid() == 1)
    .collect(Collectors.toList())
    .forEach(System.out::println);

篩選全部有效訂單並收集訂單號與訂單金額

// 篩選全部有效訂單 並收集訂單號 與 訂單金額
Map<String,Double> map=ordersList.stream().filter((order) -> order.getIsValid() == 1).
    collect(Collectors.toMap(Order::getOrderNo, Order::getTotal));
// java8 下對map進行遍歷操做 若是 Map的Key重複,會報錯
map.forEach((k,v)->{
    System.out.println("k:"+k+":v:"+v);
});

彙總

彙總操做在Stream流操做比較常見，好比計算總數，求平均等操做，經常使用方法以下:

相關操做以下

篩選全部有效訂單返回訂單總數

System.out.println("count結果:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .collect(Collectors.counting())
                  );
System.out.println("count結果:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .count()
                  );

返回訂單總金額

System.out.println("訂單總金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .collect(Collectors.summarizingDouble(Order::getTotal))
                  );
System.out.println("訂單總金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .mapToDouble(Order::getTotal)
                            .sum()
                  );
System.out.println("訂單總金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .map(Order::getTotal)
                            .reduce(Double::sum)
                            .get()
                  );

返回用戶id=20 有效訂單平均每筆消費金額

System.out.println("用戶id=20 有效訂單平均每筆消費金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .filter((order -> order.getUserId()==20))
                            .collect(Collectors.averagingDouble(Order::getTotal))
                  );
System.out.println("用戶id=20 有效訂單平均每筆消費金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .filter((order -> order.getUserId()==20))
                            .mapToDouble(Order::getTotal)
                            .average()
                            .getAsDouble()
                  );

System.out.println("用戶id=20 有效訂單平均每筆消費金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .filter((order -> order.getUserId()==20))
                            .collect(Collectors.summarizingDouble(Order::getTotal))
                            .getAverage()
                  );

篩選全部有效訂單並計算訂單總金額

System.out.println("訂單總金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .collect(Collectors.summingDouble(Order::getTotal))
                  );

最值

篩選全部有效訂單並計算最小訂單金額

System.out.println("最小訂單金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .map(Order::getTotal)
                            .collect(Collectors.minBy(Double::compare))
                  );

篩選全部有效訂單並計算最大訂單金額

// 篩選全部有效訂單 並計算最大訂單金額
System.out.println("最大訂單金額:"+
                        ordersList.stream()
                            .filter((order) -> order.getIsValid() == 1)
                            .map(Order::getTotal)
                            .collect(Collectors.maxBy(Double::compare))
                  );

分組&分區

1 分組

groupingBy 用於將數據分組，最終返回一個 Map 類型，groupingBy 第二參數用於實現多級分組

根據有效訂單支付狀態進行分組操做

Map<Integer,List<Order>> g01=ordersList.stream()
                                .filter((order) -> order.getIsValid() == 1)
                                .collect(Collectors.groupingBy(Order::getStatus));
g01.forEach((status,order)->{
    System.out.println("----------------");
    System.out.println("訂單狀態:"+status);
    order.forEach(System.out::println);
});

篩選有效訂單，根據用戶id 和支付狀態進行分組

Map<Integer,Map<String,List<Order>>> g02= ordersList.stream()
                    .filter((order) -> order.getIsValid() == 1)
                    .collect(Collectors.groupingBy(Order::getUserId,
                              Collectors.groupingBy((o)->{
                                    if(o.getStatus()==0){
                                        return "未支付";
                                    }else if (o.getStatus()==1){
                                        return "已支付";
                                    }else if (o.getStatus()==2){
                                        return "待發貨";
                                    }else if (o.getStatus()==3){
                                        return "已發貨";
                                    }else if (o.getStatus()==4){
                                        return "已接收";
                                    } else{
                                        return "已完成";
                                    }
                                }
                                ))
                            );
g02.forEach((userId,m)->{
    System.out.println("用戶id:"+userId+"-->有效訂單以下:");
    m.forEach((status,os)->{
        System.out.println("狀態:"+status+"---訂單列表以下:");
        os.forEach(System.out::println);
    });
    System.out.println("-----------------------");
});

2 分區

分區與分組的區別在於，分區是按照 true 和 false 來分的，所以partitioningBy 接受的參數的 lambda 也是 T -> boolean

分區操做-篩選訂單金額>1000 的有效訂單

Map<Boolean,List<Order>> g03= ordersList.stream()
            .filter((order) -> order.getIsValid() == 1)
            .collect(Collectors.partitioningBy((o)->o.getTotal()>1000));
g03.forEach((b,os)->{
    System.out.println("分區結果:"+b+"--列表結果:");
    os.forEach(System.out::println);
});

拼接操做-篩選有效訂單並進行拼接

String orderStr=ordersList.stream()
            .filter((order) -> order.getIsValid() == 1)
            .map(Order::getOrderNo)
            .collect(Collectors.joining(","));
System.out.println(orderStr);

流的應用

Java8引入Stream流操做，使得對元素的處理更加的方便快捷，經過Stream提供的相關方法很好的結合Lambda、函數式接口、方法引用等相關內容，使得流的處理相比較原始集合處理代碼極大簡化，Stream支持函數的鏈式調用，代碼上更加緊湊同時Stream支持的元素的並行化處理提升了程序的執行性能。

對於Stream流的應用一般在集合元素數據處理上特別是對元素須要進行屢次處理的狀況，同時對於函數式編程的味道更加濃重，也是之後開發的一個趨勢。

好了，Java8核心特性之Stream流就介紹到這裏了，應該是很是詳盡了，但願你們喜歡。