說到Stream便容易想到I/O Stream，而實際上，誰規定“流”就一定是“IO流”呢?在Java 8中，得益於Lambda所帶來的函數式編程，引入了一個全新的Stream概念，用於解決已有集合類庫既有的弊端。
引言
傳統集合的多步遍歷代碼
幾乎所有的集合(如 Collection 接口或 Map 接口等)都支持直接或間接的遍歷操作。而當我們需要對集合中的元 素進行操作的時候，除了必需的添加、刪除、獲取外，最典型的就是集合遍歷。例如：
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class DemoForEach {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "Java", "C", "Python", "Hadoop", "Spark");
for (String s : list) {
System.out.println(s);
}
}
}
運行程序，控制台輸出：
Java
C
Python
Hadoop
Spark
這是一段非常簡單的集合遍歷操作:對集合中的每一個字符串都進行打印輸出操作。
循環遍歷的弊端
Java 8的Lambda讓我們可以更加專注於做什么(What)，而不是怎么做(How)。
現在，我們仔細體會一下上例代碼，可以發現：
- for循環的語法就是“怎么做”
- for循環的循環體才是“做什么”
為什么使用循環?因為要進行遍歷。但循環是遍歷的唯一方式嗎?遍歷是指每一個元素逐一進行處理，而並不是從第一個到最后一個順次處理的循環。前者是目的，后者是方式。
試想一下，如果希望對集合中的元素進行篩選過濾：
- 將集合A根據條件一過濾為子集B;
- 然后再根據條件二過濾為子集C。
那怎么辦?在Java 8之前的做法可能為：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class DemoNormalFilter {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "Java", "C", "Python", "Hadoop", "Spark");
System.out.print("篩選前的集合：");
for (String s : list) {
System.out.print(s + "，");
}
System.out.println();
System.out.print("經過條件1篩選后的集合：");
for (String s : list) {
if (s.length() >= 4) {
System.out.print(s + "，");
}
}
System.out.println();
System.out.print("經過條件2篩選后的集合：");
for (String s : list) {
if (s.length() >= 5) {
System.out.print(s + "，");
}
}
System.out.println();
}
}
運行程序，控制台輸出：
篩選前的集合：Java，C，Python，Hadoop，Spark，
經過條件1篩選后的集合：Java，Python，Hadoop，Spark，
經過條件2篩選后的集合：Python，Hadoop，Spark，
這段代碼中含有三個循環，每一個作用不同：
1、首先從頭到尾，遍歷輸出集合。
2、然后篩選字符串長度大於等於4的元素，並輸出。
3、最后篩選字符串長度大於等於5的元素，並輸出。
每當我們需要對集合中的元素進行操作的時候，總是需要進行循環、循環、再循環。這是理所當然的么?不是。循環是做事情的方式，而不是目的。另一方面，使用線性循環就意味着只能遍歷一次。如果希望再次遍歷，只能再使用另一個循環從頭開始。
那么，Lambda的衍生物Stream能給我們帶來怎樣更加優雅的寫法呢？下面我們來看一下Stream的更優寫法。
Stream的更優寫法
下面來看一下借助Java 8的Stream API，什么才叫優雅：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Demo01Stream {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "Java", "C", "Python", "Hadoop", "Spark");
list.stream()
.filter((s) -> s.length() >= 4)
.filter((s) -> s.length() >= 5)
.forEach((s) -> System.out.println(s));
}
}
運行程序，控制台輸出：
Python
Hadoop
Spark
篩選的結果與上面的例子一致。
直接閱讀代碼的字面意思即可完美展示無關邏輯方式的語義：獲取流、過濾長度小於4的、過濾長度小於5的、逐一打印。代碼 中並沒有體現使用線性循環或是其他任何算法進行遍歷，我們真正要做的事情內容被更好地體現在代碼中。
上面程序用到的方法：
stream()方法
利用stream()方法，來獲取流。該方法是java.util.Collection接口中的一個默認方法，方法源碼如下：
// 返回以該集合為源的序列流。
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
filter()方法
該方法是java.util.stream包中的Stream接口里的一個抽象方法，方法源碼如下：
// 返回由與給定 {predicate} 匹配的此流元素組成的流。
Stream<T> filter(Predicate<? super T> predicate);
該方法的返回值是一個流，傳入的參數是一個函數式接口：java.util.function.Predicate，該接口可以對某種類型的數據進行判斷，然后返回一個布爾值。
forEach()方法
該方法是java.util.stream包中Stream接口里的一個抽象方法，方法源碼如下：
// 對該流的每個元素執行操作。
void forEach(Consumer<? super T> action);
該方法沒有返回值，傳入的參數是一個函數式接口：java.util.function.Consumer。它的作用是：消費一個數據， 其數據類型由泛型決定。
上面例子的代碼可以進行改善：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Demo02Stream {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "Java", "C", "Python", "Hadoop", "Spark");
list.stream()
.filter((s) -> s.length() >= 4)
.filter((s) -> s.length() >= 5)
.forEach(System.out::println);
}
}
其實就是修改了forEach()方法中傳入的參數，
System.out::println
(s) -> System.out.println(s)
這兩者是等價的。
流式思想概述
注意：請暫時忘記對傳統IO流的固有印象!
整體來看，流式思想類似於工廠車間的“生產流水線”。
當需要對多個元素進行操作(特別是多步操作)的時候，考慮到性能及便利性，我們應該首先拼好一個“模型”步驟 方案，然后再按照方案去執行它。
這張圖中展示了過濾、映射、跳過、計數等多步操作，這是一種集合元素的處理方案，而方案就是一種“函數模型”。圖中的每一個方框都是一個“流”，調用指定的方法，可以從一個流模型轉換為另一個流模型。而最右側的數字 3是最終結果。
這里的 filter 、 map 、 skip 都是在對函數模型進行操作，集合元素並沒有真正被處理。只有當終結方法 count 執行的時候，整個模型才會按照指定策略執行操作。而這得益於Lambda的延遲執行特性。
備注：“Stream流”其實是一個集合元素的函數模型，它並不是集合，也不是數據構，其本身並不存儲任何元素(或其地址值)。
Stream(流)是一個來自數據源的元素隊列
- 元素是特定類型的對象，形成一個隊列。 Java中的Stream並不會存儲元素，而是按需計算。
- 數據源：流的來源。 可以是集合，數組等。
和以前的Collection操作不同， Stream操作還有兩個基礎的特征：
- Pipelining：中間操作都會返回流對象本身。 這樣多個操作可以串聯成一個管道， 如同流式風格(fluent style)。 這樣做可以對操作進行優化， 比如延遲執行(laziness)和短路( short-circuiting)。
- 內部迭代：以前對集合遍歷都是通過Iterator或者增強for的方式，顯式的在集合外部進行迭代，這叫做外部迭代。 Stream提供了內部迭代的方式，流可以直接調用遍歷方法。
當使用一個流的時候，通常包括三個基本步驟:獲取一個數據源(source)→ 數據轉換→執行操作獲取想要的結果，每次轉換原有Stream 對象不改變，返回一個新的 Stream 對象(可以有多次轉換)，這就允許對其操作可以 像鏈條一樣排列，變成一個管道。