【前面的話】Java中的Stream于1.8版本析出，平時專案中也有用到，今天就系統的來實踐一下，下面借用重慶力帆隊伍中我個人比較喜歡的球員來操作一波，隊員的年齡為了便于展示某些api做了調整，請不要太認真哦，

壹. Stream理解

在java中我們稱Stream為『流』，我們經常會用流去對集合進行一些流水線的操作，stream就像工廠一樣，只需要把集合、命令還有一些引數灌輸到流水線中去，就可以加工成得出想要的結果，這樣的流水線能大大簡潔代碼，減少操作，給我個人的感覺類似JavaScript中的鏈式函式，

貳. Stream流程

原集合 —> 流 —> 各種操作(過濾、分組、統計) —> 終端操作

Stream流的操作流程一般都是這樣的，先將集合轉為流，然后經過各種操作，比如過濾、篩選、分組、計算，最后的終端操作，就是轉化成我們想要的資料，這個資料的形式一般還是集合，有時也會按照需求輸出count計數，下文會一一舉例，

叁. API實踐

首先，定義一個用戶物件，包含姓名、年齡、id三個成員變數：

package com.eelve.training.entity;

import lombok.*;

import javax.persistence.*;

/**
 * @ClassName User
 * @Description TDO
 * @Author zhao.zhilue
 * @Date 2019/6/28 15:21
 * @Version 1.0
 **/
@Data
@Entity
@Table(name = "user")
@ToString
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(exclude={"id","name"})
public class User implements  Comparable<User>{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;

    /**
     * Link name.
     */
    @Column(name = "name", columnDefinition = "varchar(255) not null")
    private String name;

    @Column(name = "age")
    private Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(User o) {
        return age.compareTo(o.getAge());
    }
}

然后在資料庫中插入測驗資料，見下圖：
streamDataSource

3.1過濾

1）filter 過濾(T-> boolean)

假如我們要實作過濾出40歲以下的隊員，我們可以這樣來實作：

@Test
    public void testUserStreamFilter(){
        List<User> userList = userMapper.getALL();
        List<User> resultList = userList.stream().filter(user -> user.getAge() <= 40).collect(Collectors.toList());
        for (User user :  resultList){
            System.out.println(user.toString());
        }
    }

filter里面，->箭頭后面跟著的是一個boolean值，可以寫任何的過濾條件，就相當于sql中where后面的東西，換句話說，能用sql實作的功能這里都可以實作
執行結果為：

User(id=1, name=費爾南多, age=25)
User(id=2, name=費爾南迪尼奧, age=26)
User(id=3, name=卡爾德克, age=27)
User(id=4, name=阿德里安, age=28)
User(id=5, name=隋維杰, age=26)

2）distinct 去重

其用法和sql中的使用類似，假如我們要實作過去除用重復年齡的隊員，我們可以這樣來實作：

@Test
    public void testUserDistinct(){
        List<User> userList = userMapper.getALL();
        List<User> resultList = userList.stream().distinct().collect(Collectors.toList());
        for (User user :  resultList){
            System.out.println(user.toString());
        }
    }

執行結果為：

User(id=1, name=費爾南多, age=25)
User(id=2, name=費爾南迪尼奧, age=26)
User(id=3, name=卡爾德克, age=27)
User(id=4, name=阿德里安, age=28)
User(id=6, name=克魯伊夫, age=43)

3）sorted排序

如果流中的元素的類實作了 Comparable 介面，即有自己的排序規則，那么可以直接呼叫 sorted() 方法對元素進行排序，如：

 @Override
    public int compareTo(User o) {
        return age.compareTo(o.getAge());
    }

@Test
    public void testUserStreamSorted(){
        List<User> userList = userMapper.getALL();
        List<User> resultList = userList.stream().sorted().collect(Collectors.toList());
        for (User user :  resultList){
            System.out.println(user.toString());
        }
    }

反之, 需要呼叫 sorted((T, T) -> int) 實作 Comparator 介面，

@Test
    public void testUserStreamSortedWithComparator(){
        List<User> userList = userMapper.getALL();
        List<User> resultList = userList.stream().sorted(Comparator.comparingInt(User::getAge)).collect(Collectors.toList());
        for (User user :  resultList){
            System.out.println(user.toString());
        }
    }

執行結果為：

User(id=1, name=費爾南多, age=25)
User(id=2, name=費爾南迪尼奧, age=26)
User(id=5, name=隋維杰, age=26)
User(id=3, name=卡爾德克, age=27)
User(id=4, name=阿德里安, age=28)
User(id=6, name=克魯伊夫, age=43)

4）limit（）回傳前n個元素

如果想知道隊伍中年齡最小的就可以使用下面來實作：

@Test
    public void testUserStreamLimit(){
        List<User> userList = userMapper.getALL();
        List<User> resultList = userList.stream().limit(2).collect(Collectors.toList());
        for (User user :  resultList){
            System.out.println(user.toString());
        }
    }

執行結果為：

User(id=1, name=費爾南多, age=25)
User(id=2, name=費爾南迪尼奧, age=26)

5）skip

它的用法和limit正好相反，是去除前面幾個元素，
假如我們要去除前面兩個元素就可以使用下面的方法來實作：

@Test
    public void testUserStreamSkip(){
        List<User> userList = userMapper.getALL();
        List<User> resultList = userList.stream().skip(2).collect(Collectors.toList());
        for (User user :  resultList){
            System.out.println(user.toString());
        }
    }

執行結果為：

User(id=3, name=卡爾德克, age=27)
User(id=4, name=阿德里安, age=28)
User(id=5, name=隋維杰, age=26)
User(id=6, name=克魯伊夫, age=43)

6）組合使用

以上的過濾函式物品們可以組合來使用來實作我們具體的需求，示例代碼如下：

 @Test
    public void testUserStreamSortLimit(){
        List<User> userList = userMapper.getALL();
        List<User> resultList = userList.stream().sorted().limit(5).collect(Collectors.toList());
        for (User user :  resultList){
            System.out.println(user.toString());
        }
    }

這樣我們就可以得到先排序后限制的結果：

User(id=1, name=費爾南多, age=25)
User(id=2, name=費爾南迪尼奧, age=26)
User(id=5, name=隋維杰, age=26)
User(id=3, name=卡爾德克, age=27)
User(id=4, name=阿德里安, age=28)

3.2 映射

1）map(T->R)

map是將T型別的資料轉為R型別的資料，比如我們想要設定一個新的list，存盤用戶所有的城市資訊，

@Test
    public void testUserStreamMap(){
        List<User> userList = userMapper.getALL();
        List<Integer> resultList = userList.stream().map(User::getAge).distinct().collect(Collectors.toList());
        System.out.println(resultList.toString());
    }

這樣我們可以得到所有年齡的樣本，執行結果為：

[25, 26, 27, 28, 43]

2）flatMap(T -> Stream)

將流中的每一個元素 T 映射為一個流，再把每一個流連接成為一個流，

@Test
    public void testStreamMap(){
        List<String> habitsList = new ArrayList<>();
        habitsList.add("唱歌,聽歌");
        habitsList.add("羽毛球,足球,登山");
        habitsList = habitsList.stream().map(s -> s.split(",")).flatMap(Arrays::stream).collect(Collectors.toList());
        System.out.println(habitsList);
    }

執行結果為：

[唱歌, 聽歌, 羽毛球, 足球, 登山]

這里原集合中的資料由逗號分割，使用split進行拆分后，得到的是Stream<String[]>，字串陣列組成的流，要使用flatMap的Arrays::stream，將Stream<String[]>轉為Stream,然后把流相連接，組成了完整的唱歌, 聽歌, 羽毛球, 足球, 登山，

3.3 查找

1）allMatch（T->boolean）

檢測是否全部滿足引數行為，假如我們要檢測是不是所有隊員都是U21的球員：

@Test
    public void testUserStreamAllMatch(){
        List<User> userList = userMapper.getALL();
        boolean isNotU21 = userList.stream().allMatch(user -> user.getAge() >= 21);
        System.out.println("是否都不是U21球員：" + isNotU21);
    }

執行結果為：

是否都不是U21球員：true

2）anyMatch（T->boolean）

檢測是否有任意元素滿足給定的條件，比如，想知道是否有26歲的球員：

@Test
    public void testUserStreamAnyMatch(){
        List<User> userList = userMapper.getALL();
        boolean isAgeU26 = userList.stream().anyMatch(user -> user.getAge() == 26);
        System.out.println("是否有26歲的球員：" + isAgeU26);
    }

執行結果為：

是否有26歲的球員：true

3）noneMatch(T -> boolean)

流中是否有元素匹配給定的 T -> boolean 條件，比如我們要檢測是否含有U18的隊員：

 @Test
    public void testUserStreamNoneMatch(){
        List<User> userList = userMapper.getALL();
        boolean isNotU18 = userList.stream().noneMatch(user -> user.getAge() <= 18);
        System.out.println("是否都不是U18球員：" + isNotU18);
    }

執行結果為：

是否都不是U18球員：true

說明沒有U18的隊員，

4）findFirst( ):找到第一個元素

@Test
    public void testUserFindFirst(){
        List<User> userList = userMapper.getALL();
        Optional<User> firstUser = userList.stream().sorted().findFirst();
        System.out.println(firstUser.toString());
    }

執行結果為：

Optional[User(id=1, name=費爾南多, age=25)]

5）findAny():找到任意一個元素

@Test
    public void testUserFindAny(){
        List<User> userList = userMapper.getALL();
        Optional<User> anytUser = userList.parallelStream().sorted().findAny();
        System.out.println(anytUser.toString());
    }

執行結果為：

Optional[User(id=2, name=費爾南迪尼奧, age=26)]

3.4 歸納計算

1）求隊員的總人數

@Test
    public void testUserCount(){
        List<User> userList = userMapper.getALL();
        long totalAge = userList.stream().collect(Collectors.counting());
        System.out.println("隊員人數為：" + totalAge);
    }

執行結果為：

隊員人數為：6

2）得到某一屬性的最大最小值

@Test
    public void testUserMaxAndMin(){
        List<User> userList = userMapper.getALL();
        Optional<User> userMaxAge = userList.stream().collect(Collectors.maxBy(Comparator.comparing(User::getAge)));
        System.out.println("年齡最大的隊員為：" + userMaxAge.toString());

        Optional<User> userMinAge = userList.stream().collect(Collectors.minBy(Comparator.comparing(User::getAge)));
        System.out.println("年齡最小的隊員為：" + userMinAge.toString());
    }

執行結果為：

年齡最大的隊員為：Optional[User(id=6, name=克魯伊夫, age=43)]
年齡最小的隊員為：Optional[User(id=1, name=費爾南多, age=25)]

3）求年齡總和是多少

@Test
    public void testUserSummingInt(){
        List<User> userList = userMapper.getALL();
        int totalAge = userList.stream().collect(Collectors.summingInt(User::getAge));
        System.out.println("年齡總和為：" + totalAge);
    }

執行結果為：

年齡總和為：175

我們經常會用BigDecimal來記錄金錢，假設想得到BigDecimal的總和：
// 獲得串列物件金額，使用reduce聚合函式,實作累加器
BigDecimal sum = myList.stream() .map(User::getMoney)
.reduce(BigDecimal.ZERO,BigDecimal::add);

4）求年齡平均值

@Test
    public void testUserAveragingInt(){
        List<User> userList = userMapper.getALL();
        Double totalAge = userList.stream().collect(Collectors.averagingInt(User::getAge));
        System.out.println("平均年齡為：" + totalAge);
    }

執行結果為：

平均年齡為：29.166666666666668

5）一次性得到元素的個數、總和、最大值、最小值

@Test
    public void testUserSummarizingInt(){
        List<User> userList = userMapper.getALL();
        IntSummaryStatistics  statistics  = userList.stream().collect(Collectors.summarizingInt(User::getAge));
        System.out.println("年齡的統計結果為：" + statistics );
    }

執行結果為：

年齡的統計結果為：IntSummaryStatistics{count=6, sum=175, min=25, average=29.166667, max=43}

6）字串拼接

要將隊員的姓名連成一個字串并用逗號分割，

@Test
    public void testUserJoining(){
        List<User> userList = userMapper.getALL();
        String  name  = userList.stream().map(User::getName).collect(Collectors.joining(","));
        System.out.println("所有的隊員名字：" + name );
    }

執行結果為：

所有的隊員名字：費爾南多,費爾南迪尼奧,卡爾德克,阿德里安,隋維杰,克魯伊夫

3.5 分組

在資料庫操作中，我們經常通過GROUP BY關鍵字對查詢到的資料進行分組，java8的流式處理也提供了分組的功能，使用Collectors.groupingBy來進行分組，

1）可以根據隊員的年齡進行分組

 @Test
    public void testUserGroupingBy(){
        List<User> userList = userMapper.getALL();
        Map<Integer, List<User>> ageMap  = userList.stream().collect(Collectors.groupingBy(User::getAge));
        for (Map.Entry<Integer,List<User>> entry :ageMap.entrySet()){
            System.out.println("key= " + entry.getKey() + " and value= "https://www.cnblogs.com/eelve/archive/2021/01/02/+ entry.getValue());
        }
    }

執行結果為：

key= 25 and value= https://www.cnblogs.com/eelve/archive/2021/01/02/[User(id=1, name=費爾南多, age=25)]
key= 26 and value= [User(id=2, name=費爾南迪尼奧, age=26), User(id=5, name=隋維杰, age=26)]
key= 43 and value= [User(id=6, name=克魯伊夫, age=43)]
key= 27 and value= [User(id=3, name=卡爾德克, age=27)]
key= 28 and value= [User(id=4, name=阿德里安, age=28)]

結果是一個map，key為不重復的年齡，value為屬于該年齡的隊員串列，已經實作了分組，另外我們還可以繼續分組得到兩次分組的結果，

2）如果僅僅想統計各年齡的隊員個數是多少，并不需要對應的list

按年齡分組并統計人數：

@Test
    public void testUserGroupingByCount(){
        List<User> userList = userMapper.getALL();
        Map<Integer,Long> ageMap  = userList.stream().collect(Collectors.groupingBy(User::getAge,Collectors.counting()));
        for (Map.Entry<Integer,Long> entry :ageMap.entrySet()){
            System.out.println("隊員中" + entry.getKey() + "歲的隊員人數為：" + entry.getValue());
        }
    }

執行結果為：

隊員中25歲的隊員人數為：1
隊員中26歲的隊員人數為：2
隊員中43歲的隊員人數為：1
隊員中27歲的隊員人數為：1
隊員中28歲的隊員人數為：1

3）partitioningBy 磁區

磁區與分組的區別在于，磁區是按照 true 和 false 來分的，因此partitioningBy 接受的引數的 lambda 也是 T -> boolean

@Test
    public void testUserPartitioningBy (){
        List<User> userList = userMapper.getALL();
        Map<Boolean,List<User>> partitioningByMap  = userList.stream().collect(partitioningBy(user -> user.getAge() >= 30));
        for (Map.Entry<Boolean,List<User>> entry :partitioningByMap.entrySet()){
            System.out.println("key= " + entry.getKey() + " and value= "https://www.cnblogs.com/eelve/archive/2021/01/02/+ entry.getValue());
        }
    }

執行結果為：

key= false and value= https://www.cnblogs.com/eelve/archive/2021/01/02/[User(id=1, name=費爾南多, age=25), User(id=2, name=費爾南迪尼奧, age=26), User(id=3, name=卡爾德克, age=27), User(id=4, name=阿德里安, age=28), User(id=5, name=隋維杰, age=26)]
key= true and value= [User(id=6, name=克魯伊夫, age=43)]

【寫在后面的話】留下stream的類實作的方法和依賴圖，前面的實踐也只是挑選了幾個比較常用的Api，

stream

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/243769.html

標籤：其他

上一篇：【Java流程控制】Java回圈結構 while、do...while、for 用法與區別總結

下一篇：Docker 的 2020，實 "鼠" 不易！

Java 8 Stream實踐

壹. Stream理解

貳. Stream流程

叁. API實踐

3.1過濾

1）filter 過濾(T-> boolean)

2）distinct 去重

3）sorted排序

4）limit（） 回傳前n個元素

5）skip

6）組合使用

3.2 映射

1）map(T->R)

2）flatMap(T -> Stream)

3.3 查找

1）allMatch（T->boolean）

2）anyMatch（T->boolean）

3）noneMatch(T -> boolean)

4）findFirst( ):找到第一個元素

5）findAny():找到任意一個元素

3.4 歸納計算

1）求隊員的總人數

2）得到某一屬性的最大最小值

3）求年齡總和是多少

4）求年齡平均值

5）一次性得到元素的個數、總和、最大值、最小值

6）字串拼接

3.5 分組

1）可以根據隊員的年齡進行分組

2）如果僅僅想統計各年齡的隊員個數是多少，并不需要對應的list

3）partitioningBy 磁區

4）limit（）回傳前n個元素