Java8中怎么實現Stream流式操作

Java8中怎么實現Stream流式操作，相信很多沒有經驗的人對此束手無策，為此本文總結了問題出現的原因和解決方法，通過這篇文章希望你能解決這個問題。

1. 流是什么

流是一種以聲明性的方式來處理數據的API

什么是聲明性的方式？

就是只聲明，不實現，類似抽象方法（多態性）

2. 老板，上栗子

下面我們舉個栗子，來看下什么是流式操作，然后針對這個栗子，引出后面的相關概念

需求：篩選年齡大于1的貓（貓的1年≈人的5年），并按年齡遞增排序，最后提取名字單獨存放到列表中

public class BasicDemo {
    public static void main(String[] args) {
      // 以下貓的名字均為真名，非虛構
        List<Cat> list = Arrays.asList(new Cat(1, "tangyuan"), new Cat(3, "dangdang"), new Cat(2, "milu"));
        // === 舊代碼 Java8之前 ===
        List<Cat> listTemp = new ArrayList<>();
        // 1. 篩選
        for(Cat cat: list){
            if(cat.getAge()>1){
                listTemp.add(cat);
            }
        }
        // 2. 排序
        listTemp.sort(new Comparator<Cat>() {
            @Override
            public int compare(Cat o1, Cat o2) {
                // 遞增排序
                return Integer.compare(o1.getAge(), o2.getAge());
            }
        });
        // 3. 提取名字
        List<String> listName = new ArrayList<>();
        for(Cat cat: listTemp){
            listName.add(cat.getName());
        }
        System.out.println(listName);
        
        // === 新代碼 Java8之后 ===
        List<String> listNameNew = list.stream()
          			// 函數式接口 Predicate的 boolean test(T t)抽象方法
                .filter(cat -> cat.getAge() > 1)
								// lambda表達式的方法引用
			          .sorted(Comparator.comparingInt(Cat::getAge))
          			// 函數式接口 Funtion的 R apply(T t)抽象方法
                .map(cat-> cat.getName())
             	  // 收集數據，把流轉為集合List
                .collect(Collectors.toList());
        System.out.println(listNameNew);
    }
}
class Cat{
    int age;
    String name;

    public Cat(int age, String name) {
        this.age = age;
        this.name = name;
    }
	// 省略getter/setter
}

可以看到，用了流式操作，代碼簡潔了很多（秒哇）

Q：有的官人可能會想，這跟前面lambda表達式的組合操作有點像啊。

A：你說對了，確實只是像，區別還是很大的。因為lambda表達式的組合操作其實還是屬于直接針對集合的操作；

文末會講到直接操作集合和流式操作的區別，這里先跳過

下面我們基于這個栗子，來分別介紹涉及到的知識點

3. 流的操作步驟

我們先忽略舊版的集合操作（后面介紹流和集合的區別時再說），先來介紹流的操作（畢竟流才是今天的主角嘛）

流的操作分三步走：創建流、中間操作、終端操作

流程如下圖：

這里我們要關注一個很重要的點：

在終端操作開始之前，中間操作不會執行任何處理，它只是聲明執行什么操作；

你可以想象上面這個流程是一個流水線：我們這里做個簡化處理

1. 目的：先告訴你，我們要加工瓶裝的水（先創建流，告訴你要處理哪些數據）

2. 再針對這些瓶子和水，來搭建一個流水線：固定瓶子的夾具、裝水的水管、擰蓋子的爪子、裝箱的打包器（中間操作，聲明要執行的操作）

3. 最后按下啟動按鈕，流水線開始工作（終端操作，開始根據中間操作來處理數據）

因為每一個中間操作都是返回一個流（Stream），這樣他們就可以一直組合下去（我好像吃到了什么東西？），但是他們的組合順序是不固定的，流會根據系統性能去選擇合適的組合順序

我們可以打印一些東西來看下：

List<Cat> list = Arrays.asList(new Cat(1, "tangyuan"), new Cat(3, "dangdang"), new Cat(2, "milu"));
List<String> listNameNew = list.stream()
  .filter(cat -> {
    System.out.println("filter: " + cat);
    return cat.getAge() > 1;
  })
  .map(cat-> {
    System.out.println("map:" + cat);
    return cat.getName();
  })
  .collect(Collectors.toList());

輸出如下：

filter: Cat{age=1}
filter: Cat{age=3}
map:Cat{age=3}
filter: Cat{age=2}
map:Cat{age=2}

可以看到，中間操作的filter和map組合到一起交叉執行了，盡管他們是兩個獨立的操作（這個技術叫作循環合并）

這個合并主要是由流式操作根據系統的性能來自行決定的

既然講到了循環合并，那下面捎帶說下短路技巧

短路這個詞大家應該比較熟悉（比如腦子短路什么的），指的是本來A->B->C是都要執行的，但是在B的地方短路了，所以就變成了A->C了

這里的短路指的是中間操作，由于某些原因（比如下面的limit），導致只執行了部分，沒有全部去執行

我們來修改下上面的例子（加了一個中間操作limit)：

List<Cat> list = Arrays.asList(new Cat(1, "tangyuan"), new Cat(3, "dangdang"), new Cat(2, "milu"));
List<String> listNameNew = list.stream()
  .filter(cat -> {
    System.out.println("filter: " + cat);
    return cat.getAge() > 1;
  })
  .map(cat-> {
    System.out.println("map:" + cat);
    return cat.getName();
  })
  // 只加了這一行
  .limit(1)
  .collect(Collectors.toList());

輸出如下：

filter: Cat{age=1}
filter: Cat{age=3}
map:Cat{age=3}

可以看到，因為limit(1)只需要一個元素，所以filter過濾時，只要找到一個滿足條件的，就會停止過濾操作（后面的元素就放棄了），這個技巧叫做短路技巧

這個就很大程度上體現了中間操作的組合順序帶來的優點：需要多少，處理多少，即按需處理

4. 流的特點

特點有三個：

• 聲明性：簡潔，易讀，代碼行數大大減少（每天有代碼行數要求的公司除外）

• 可復合：更靈活，各種組合都可以（只要你想，只要流有）

• 可并行：性能更好（不用我們去寫多線程，多好）

5. 流式操作和集合操作的區別：

現在我們再來回顧下開頭例子中的集合操作：篩選->排序->提取

List<Cat> listTemp = new ArrayList<>();
// 1. 篩選
for(Cat cat: list){
  if(cat.getAge()>1){
    listTemp.add(cat);
  }
}
// 2. 排序
listTemp.sort(new Comparator<Cat>() {
  @Override
  public int compare(Cat o1, Cat o2) {
    // 遞增排序
    return Integer.compare(o1.getAge(), o2.getAge());
		/**
    * Q：為啥不用減法 return o1.getAge() - o2.getAge()？
    * A：因為減法會有數據溢出的風險
    * 	 如果o1.getAge()為20億，o2.getAge()為-2億，那么結果就會超過int的極限21億多
    **/ 
  }
});
// 3. 提取名字
List<String> listName = new ArrayList<>();
for(Cat cat: listTemp){
  listName.add(cat.getName());
}
System.out.println(listName);

可以看到跟流式操作不一樣的有兩點：

1. 集合操作中有一個listTemp臨時變量（流式操作沒），

2. 集合操作一直都在處理數據（而流式操作是直到最后一步的終端操作才會去處理數據），依次篩選->排序->提取名字，是順序執行的

下面我們用表格來列出區別，應該會直觀點

用生活中的例子來對比的話，可以用電影來比喻

流就好比在線觀看，集合就好本地觀看（下載到本地）

總結

1. 流是什么：

• 源：數據的來源，比如集合，文件等（本節只介紹了集合的流式操作，因為用的比較多；后面有空再介紹其他的）

• 數據處理操作：就是流的中間操作，比如filter, map

• 元素序列：通過流的終端操作，返回的結果集

• 流是一種以聲明性的方式來處理數據的API

• 流是從支持數據處理操作的源生成的元素序列

2. 流的操作流程：

• 創建流 -> 中間操作 -> 終端操作

• 中間操作只是聲明，不真實處理數據，直到終端操作開始才會執行

3. 循環合并：中間操作會自由組合（流根據系統自己來決定組合的順序）

4. 短路技巧：如果中間操作處理的數據已經達到需求，則會立即停止處理數據（比如limit(1)，則當處理完1個就會停止處理）

5. 流式操作和集合操作的區別：

• 流按需處理，集合全處理

• 流主攻數據處理，集合主攻數據存儲

• 流簡潔，集合不

• 流內部迭代（只迭代一次，完后流會消失），集合外部迭代（可一直迭代）

看完上述內容，你們掌握Java8中怎么實現Stream流式操作的方法了嗎？如果還想學到更多技能或想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！