摘要：會在數據源內部隱式的遍歷進行處理。會并行遍歷數據，將數據分成若干段，同時進行處理，最終匯總結果一起輸出。結束操作會觸發實際計算，計算發生時會把所有中間操作積攢的操作以的方式執行，這樣可以減少迭代次數。為函數式編程而生。

Stream實現了對數據源的流式處理，它可以并行操作，提高數據處理效率。

流不是集合，它不對數據做保存，只是最數據進行算法處理，比如最大值，最小值，排序等操作。Stream會在數據源內部隱式的遍歷進行處理。Stream會并行遍歷數據，將數據分成若干段，同時進行處理，最終匯總結果一起輸出。

Stream 就如同一個迭代器（Iterator），單向，不可往復，數據只能遍歷一次，遍歷過一次后即用盡了，就好比流水從面前流過，一去不復返。

首先對stream的操作可以分為兩類，中間操作(intermediate operations)和結束操作(terminal operations):

中間操作總是會惰式執行，調用中間操作只會生成一個標記了該操作的新stream。

結束操作會觸發實際計算，計算發生時會把所有中間操作積攢的操作以pipeline的方式執行，這樣可以減少迭代次數。計算完成之后stream就會失效。

無存儲。stream不是一種數據結構，它只是某種數據源的一個視圖，數據源可以是一個數組，Java容器或I/O channel等。

為函數式編程而生。對stream的任何修改都不會修改背后的數據源，比如對stream執行過濾操作并不會刪除被過濾的元素，而是會產生一個不包含被過濾元素的新stream。

惰式執行。stream上的操作并不會立即執行，只有等到用戶真正需要結果的時候才會執行。

可消費性。stream只能被“消費”一次，一旦遍歷過就會失效，就像容器的迭代器那樣，想要再次遍歷必須重新生成。

public class StreamStudy {
    
    public static void main(String[] args) throws Exception {
        //1. of
        Stream stream  = Stream.of("hello","java","python");
        // 2. Arrays
        String [] strArray = new String[] {"hello","java","python"};
        stream = Stream.of(strArray);
        stream = Arrays.stream(strArray);
        // 3. Collections
        List list = Arrays.asList(strArray);
        stream = list.stream();
        System.out.println(stream.findAny());
    }

}

最終只返回第一個結果： Optional[hello]

public class StreamStudy {
    
    public static void main(String[] args) throws Exception {
        String [] strArray = new String[] {"hello","java","python"};
        List list = Arrays.asList(strArray);
        // to array
        System.out.println(list.stream().toArray()[0]);
        // to list
        System.out.println(list.stream().collect(Collectors.toList()));
        // to string
        System.out.println(list.stream().collect(Collectors.joining()).toString());
    }

}

輸出：
hello
[hello, java, python]
hellojavapython

Intermediate （map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered）

Terminal（forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator）

Short-circuiting（anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit）

一個流可以后面跟隨零個或多個 intermediate 操作。其目的主要是打開流，做出某種程度的數據映射/過濾，然后返回一個新的流，交給下一個操作使用。這類操作都是惰性化的（lazy），就是說，僅僅調用到這類方法，并沒有真正開始流的遍歷。

一個流只能有一個 terminal 操作，當這個操作執行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個操作。Terminal 操作的執行，才會真正開始流的遍歷，并且會生成一個結果，或者一個 side effect。

public class StreamStudy {
    
    public static void main(String[] args) throws Exception {
        String [] strArray = new String[] {"hello","java","python"};
        List list = Arrays.asList(strArray);
        list.stream().map((v) ->v.toUpperCase())
        .forEach(t -> System.out.println(t));
    }

}

將ｌｉｓｔ中的所有字母轉換成大寫，然后遍歷輸出。　實際ｌｉｓｔ中的值并沒有改變，我們只是借助Ｓｔｒｅａｍ來做業務處理。
輸出　：
HELLO
JAVA
PYTHON

public class StreamStudy {
    
    public static void main(String[] args) throws Exception {
        String [] strArray = new String[] {"hello","java","python"};
        List list = Arrays.asList(strArray);
        list.stream().filter(f -> f.length()>4)
        .map(v ->v.toUpperCase())
        .forEach(t -> System.out.println(t));
    }

}

先ｆｉｌｔｅｒ過濾，然后ｍａｐ字母大寫，最后forEach輸出結果：
HELLO
PYTHON

public class StreamStudy {
    
    public static void main(String[] args) throws Exception {
        String [] strArray = new String[] {"hello","java","python","node","react","vue"};
        List list = Arrays.asList(strArray);
        list.stream().filter(f -> f.length()>3)
        .sorted((a,b) -> b.compareTo(a))
        .map(v ->v.toUpperCase())
        .forEach(t -> System.out.println(t));
    }

}

先ｆｉｌｔｅｒ過濾，然后sorted排序，然后ｍａｐ字母大寫，最后forEach輸出結果：
REACT
PYTHON
NODE
JAVA
HELLO

public class StreamStudy {
    
    public static void main(String[] args) throws Exception {
        String [] strArray = new String[] {"hello","java","python","node","react","vue","React"};
        List list = Arrays.asList(strArray);
        list.stream().filter(f -> f.length()>3)
        .sorted((a,b) -> b.compareTo(a))
        .map(v ->v.toUpperCase())
        .distinct()
        .forEach(t -> System.out.println(t));
    }

}

distinct去重，使用 Object.equals(Object)來判斷是否重復，最終只留下一個ＲＥＡＣＴ，結果：
REACT
PYTHON
NODE
JAVA
HELLO

public class StreamStudy {
    
    public static void main(String[] args) throws Exception {
        String [] strArray = new String[] {"hello","java","python","node","react","vue","React"};
        List list = Arrays.asList(strArray);
        list.stream().filter(f -> f.length()>3)
        .sorted((a,b) -> b.compareTo(a))
        .map(v ->v.toUpperCase())
        .distinct()
        .limit(3)
        .forEach(t -> System.out.println(t));
    }

}

limit限制元素個數，這里著要前３個結果：
REACT
PYTHON
NODE

public class StreamStudy {
    
    public static void main(String[] args) throws Exception {
        String [] strArray = new String[] {"hello","java","python","node","react","vue","React"};
        List list = Arrays.asList(strArray);
        list.stream().filter(f -> f.length()>3)
        .sorted((a,b) -> b.compareTo(a))
        .map(v ->v.toUpperCase())
        .distinct()
        .limit(3)
        .peek(p -> p.toLowerCase())
        .forEach(t -> System.out.println(t));
        
    }

}

peek會對每個元素執行操作，并返回包含原ｓｔｒｅａｍ元素的新Ｓｔｒｅａｍ，什么意思呢？先看結果：
REACT
PYTHON
NODE
并不是我們看到的小寫，因為ｐｅｅｋ產生的新的ｓｔｒｅａｍ并不是我們已開始處理的Ｓｔｒｅａｍ，所以我們看到的還是大寫。如果你的處理過程中涉及一些額外邏輯，但不影響最終結果，那么你可以使用ｐｅｅｋ去搞一個新的Ｓｔｒｅａｍ去處理。

我們主要使用的是Intermediate 中的方法進行數據處理，Terminal 中的方法只能使用一個，這意味著對流的處理終止，這時才開始執行前面的那些Intermediate方法。最后對一些方法作一些解釋，就不一一演示了：
forEach遍歷、 forEachOrdered按順序遍歷、 toArray結果轉換成數組、 reduce結果中的元素進行組合、 collect結果轉換成集合、 min結果中最小值、 max結果中最大值、 count結果中元素數量、 anyMatch結果中存在元素滿足某一條件、 allMatch結果中所有元素都滿足某一條件、 noneMatch結果中所有元素都不滿足某一條件、 findFirst結果中第一條數據　、 findAny結果中的任意一條數據、 iterator遍歷