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

Stream實現(xiàn)了對數(shù)據(jù)源的流式處理，它可以并行操作，提高數(shù)據(jù)處理效率。

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

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

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

中間操作總是會惰式執(zhí)行，調(diào)用中間操作只會生成一個標(biāo)記了該操作的新stream。

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

無存儲。stream不是一種數(shù)據(jù)結(jié)構(gòu)，它只是某種數(shù)據(jù)源的一個視圖，數(shù)據(jù)源可以是一個數(shù)組，Java容器或I/O channel等。

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

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

可消費性。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());
    }

}

最終只返回第一個結(jié)果： 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 操作。其目的主要是打開流，做出某種程度的數(shù)據(jù)映射/過濾，然后返回一個新的流，交給下一個操作使用。這類操作都是惰性化的（lazy），就是說，僅僅調(diào)用到這類方法，并沒有真正開始流的遍歷。

一個流只能有一個 terminal 操作，當(dāng)這個操作執(zhí)行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個操作。Terminal 操作的執(zhí)行，才會真正開始流的遍歷，并且會生成一個結(jié)果，或者一個 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));
    }

}

將ｌｉｓｔ中的所有字母轉(zhuǎn)換成大寫，然后遍歷輸出。　實際ｌｉｓｔ中的值并沒有改變，我們只是借助Ｓｔｒｅａｍ來做業(yè)務(wù)處理。
輸出?。?br>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輸出結(jié)果：
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輸出結(jié)果：
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)來判斷是否重復(fù)，最終只留下一個ＲＥＡＣＴ，結(jié)果：
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限制元素個數(shù)，這里著要前３個結(jié)果：
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會對每個元素執(zhí)行操作，并返回包含原ｓｔｒｅａｍ元素的新Ｓｔｒｅａｍ，什么意思呢？先看結(jié)果：
REACT
PYTHON
NODE
并不是我們看到的小寫，因為ｐｅｅｋ產(chǎn)生的新的ｓｔｒｅａｍ并不是我們已開始處理的Ｓｔｒｅａｍ，所以我們看到的還是大寫。如果你的處理過程中涉及一些額外邏輯，但不影響最終結(jié)果，那么你可以使用ｐｅｅｋ去搞一個新的Ｓｔｒｅａｍ去處理。

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