摘要：將在非空的時(shí)候返回值，否則會(huì)拋出沒有這個(gè)元素的異常。構(gòu)建流現(xiàn)在我們已經(jīng)能夠使用從集合生成流了。由文件生成流不重復(fù)的單詞數(shù)預(yù)處理獲取流，使用后不用手動(dòng)關(guān)閉流。我們使用得到流，其中每個(gè)元素就是文本里的一行。

filter 會(huì)接受一個(gè)謂詞作為參數(shù)，并返回符合該條件的元素流。

        List vegetarianMenu = menu
                .stream()
                .filter(Dish::getVegetarian)
                .collect(Collectors.toList());

會(huì)篩選出素食的菜肴。

distinct 會(huì)返回一個(gè)元素各異的流，也就是去重。

        List caloriesMenu = menu
                .stream()
                .filter((Dish dish) -> 350 == dish.getCalories())
                .map(Dish::getCalories)
                .distinct()
                .collect(Collectors.toList());

會(huì)篩選出卡路里為350的菜肴并去重（米飯和對(duì)蝦二選一）。

limit(n) 會(huì)返回一個(gè)不超過給定長(zhǎng)度的流。

        List caloriesMenu = menu
                .stream()
                .filter((Dish dish) -> 350 < dish.getCalories())
                .limit(3)
                .collect(Collectors.toList());

List 是有序集合所以會(huì)順序篩選出三個(gè)，而如果是 Set 無(wú)序的則不會(huì)以任何順序排列。

skip(n) 返回一個(gè)人掉了前 n 個(gè)元素的流，和 limit(n) 是互補(bǔ)的。

        List caloriesMenu = menu
                .stream()
                .filter((Dish dish) -> 350 < dish.getCalories())
                .skip(3)
                .collect(Collectors.toList());

map 返回一個(gè)映射好的元素流。如果我們要找出每個(gè)菜肴的名稱有多長(zhǎng)，那么可以這樣思考：第一，我們需要知道菜肴的名稱。第二，計(jì)算菜肴名稱的長(zhǎng)度。

        List caloriesMenu = menu
                .stream()
                // 映射名稱字符串
                .map(Dish::getName)
                // 映射字符串長(zhǎng)度
                .map(String::length)
                .collect(Collectors.toList());

返回菜肴名稱的長(zhǎng)度已經(jīng)做到了，如果有奇怪的需求，比如將菜肴名稱打碎成字符并去重……

        List caloriesMenu = menu
                .stream()
                // 映射名稱字符串
                .map(Dish::getName)
                // 將字符串分割為字符數(shù)組 String[]
                .map((String string) -> string.split(""))
                // Arrays.stream() 可以接收一個(gè)數(shù)組并產(chǎn)生一個(gè)流，再調(diào)用 flatMap 將其轉(zhuǎn)成單個(gè)流
                .flatMap(Arrays::stream)
                // 去重
                .distinct()
                // 保存
                .collect(Collectors.toList());

扁平化在這里就是讓字符數(shù)組不是分別映射成一個(gè)流，而是映射成流的內(nèi)容，然后將使用 Arrays::stream 時(shí)生成的單個(gè)流都被合并起來(lái)。

anyMatch 可以檢查謂詞是否至少匹配一個(gè)元素。

        // 檢查是否至少含有一道是素食的菜肴
        Boolean b = menu
                .stream()
                .anyMatch(Dish::getVegetarian);

allMatch 可以檢查謂詞是否全部匹配。

        // 檢查是否全部是素食
        Boolean b = menu
                .stream()
                .anyMatch(Dish::getVegetarian);

noneMatch 可以檢查謂詞是否全部不匹配。

        // 檢查是否全部不是素食
        Boolean b = menu
                .stream()
                .noneMatch(Dish::getVegetarian);

以上這三種操作都用到了所謂的短路，也和 Java 中!、&&和||運(yùn)算符意義一樣。

findAny 將返回當(dāng)前流中的任意元素。

        Optional dishOptional = menu
                .stream()
                .findAny();

Optional 是一個(gè)容器類，代表一個(gè)值存在或不存在。有可能 findAny 什么也沒找到，所以如果用 Dish 對(duì)象直接裝可能會(huì)報(bào)空指針錯(cuò)誤。本章不會(huì)深入了解 Optional，但可以先簡(jiǎn)單介紹一下這個(gè)類的一些有用的方法。

isPresent() 將在非空的時(shí)候返回 true。

ifPresent(Consumer consumer) 將在非空的時(shí)候執(zhí)行 Consumer 的代碼，再第二章的時(shí)候我們知道 Consumer 可以接受一個(gè)對(duì)象并進(jìn)行操作。

T get() 將在非空的時(shí)候返回值，否則會(huì)拋出沒有這個(gè)元素的異常。

T orElse(T other) 將在非空的時(shí)候返回值，否則返回一個(gè)默認(rèn)值。

比如上面的代碼可以變成這樣

        menu.stream().findAny().ifPresent(System.out::println);

就可以打印輸出任意菜肴的信息。

與 findAny 類似，只不過返回有序集合的第一個(gè)元素。

        Optional dishOptional = menu
                .stream()
                .findFirst();

那么 findAny 和 findFirst 有什么區(qū)別呢？在并行計(jì)算里面，找到第一個(gè)元素會(huì)需要很多思考，所以一般在并行處理時(shí)用 findAny。

reduce 操作可以吧一個(gè)流中的元素組合起來(lái)，比如菜單里的總卡路里。此類查詢需要將流中所有元素反復(fù)結(jié)合起來(lái)，得到一個(gè)值。這樣的查詢操作可以被歸類為 歸約 操作，用函數(shù)式編程語(yǔ)言的術(shù)語(yǔ)來(lái)說(shuō)，這稱為 折疊。

平常使用 for-each 來(lái)處理總卡路里我們一般會(huì)這樣做

        Integer integer = 0;
        for (Dish dish : menu) {
            integer += dish.getCalories();
        }

在流中可以使用 reduce 方法來(lái)處理

        Integer integer = menu
                .stream()
                .map(Dish::getCalories)
                .reduce(0, (Integer a, Integer b) -> a + b);

好像有點(diǎn)復(fù)雜，沒關(guān)系，接下來(lái)可以詳細(xì)講解。

首先我們用 map 將 Dish 對(duì)象映射成其卡路里值的 Integer 類型。然后調(diào)用 reduce 將每個(gè)映射好的 Integer 組合（相加）。其中 reduce 方法第一個(gè)參數(shù)代表初始值，后面跟著一個(gè) BinaryOperator 的函數(shù)式接口。這個(gè)函數(shù)式接口目的就是將兩個(gè)元素組合。

可以看一下 BinaryOperator 的源碼

@FunctionalInterface
public interface BinaryOperator extends BiFunction {
    public static  BinaryOperator minBy(Comparator comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    public static  BinaryOperator maxBy(Comparator comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

實(shí)際上我們調(diào)用的是第三章有提到過的 BiFunction 里的 apply 方法

@FunctionalInterface
public interface BiFunction {
    R apply(T t, U u);
}

BinaryOperator 它接受兩個(gè)同類型參數(shù)并返回一個(gè)同類型的對(duì)象。

所以我們可以這樣來(lái)寫

        BinaryOperator integerBinaryOperator = (Integer a, Integer b) -> a + b;

代表計(jì)算 a + b。而 reduce 自帶循環(huán)，所以會(huì)在背后進(jìn)行類似于 a += b 一樣的邏輯操作。reduce還有一個(gè)重載的版本，可以不接受初始值返回一個(gè) Optional 對(duì)象。

        Optional integer = menu
                .stream()
                .map(Dish::getCalories)
                .reduce((Integer a, Integer b) -> a + b);

用 Optional 的意義與之前一樣，考慮到了集合為空的情況。

reduce 同樣可以用來(lái)做大小比較，因?yàn)槠湫枰?BinaryOperator 自帶有比較方法。

最大

        Optional integer = menu
                .stream()
                .map(Dish::getCalories)
                .reduce(Integer::max);

其中 reduce(Integer::max) 是

        reduce((Integer integer1, Integer integer2) -> Integer.max(integer1, integer2))

的縮寫。計(jì)算最小值只需要將 max 換成 min 就行。歸納方法的對(duì)比傳統(tǒng)的 for-each 優(yōu)勢(shì)是可以把內(nèi)部迭代抽象化，這讓其內(nèi)部可以并行化而不用我們自己去實(shí)現(xiàn)并行處理。

但是這種并行是有限制的，不是將所有的 stream 換成 parallelStream 就行了。

像 map 或 filter 等操作會(huì)從輸入流中獲取每一個(gè)元素并在輸出流中得到至多一個(gè)結(jié)果。這些操作一般是無(wú)狀態(tài)的，做并行是可行的。

像 reduce、max 等操作需要內(nèi)部狀態(tài)來(lái)累積結(jié)果，因?yàn)榍蠛涂隙ㄊ切枰皵?shù)的和加上現(xiàn)在選擇的這個(gè)元素，但無(wú)論哪個(gè)都是有限的，所以稱為有界，是可以直接做并行。

相反，如同 distinct 操作，是需要接受一個(gè)流再生成一個(gè)流，并且去重操作是需要知道先前的歷史流是什么樣的，例如把所有質(zhì)數(shù)倒序，就需要最大的那個(gè)質(zhì)數(shù)，但這是不存在的，所以稱為無(wú)界狀態(tài)。做并行需要好生思考一番。

關(guān)于去重，其實(shí)可以換一種思路，將有序集合（List）轉(zhuǎn)為無(wú)序集合（Set）就自動(dòng)去重了。

        Set caloriesMenu = menu
                .stream()
                .filter((Dish dish) -> 350 == dish.getCalories())
                .map(Dish::getCalories)
                .collect(Collectors.toSet());

在和數(shù)字打交道時(shí)，比較常用的就是在一個(gè)數(shù)值范圍內(nèi)生成數(shù)字。Java 8引入了兩個(gè)可以用于 IntStream 和 LongStream 的靜態(tài)方法，幫助生成范圍：range 和 rangeClosed。是不包含結(jié)束值的，比如傳入(0,100)就會(huì)運(yùn)算到99結(jié)束。

比如我們需要統(tǒng)計(jì)0～100里偶數(shù)的個(gè)數(shù)（包含100）

        long l = IntStream
                .rangeClosed(0, 100)
                .filter((int n) -> n % 2 == 0)
                .count();

這樣就統(tǒng)計(jì)出了51個(gè)偶數(shù)個(gè)數(shù)，如果不包含100就用 range，會(huì)統(tǒng)計(jì)50個(gè)。

現(xiàn)在我們已經(jīng)能夠使用 Stream 從集合生成流了。那么如何從值序列、數(shù)組和文件生成流，甚至函數(shù)來(lái)創(chuàng)建無(wú)限流？

        Stream stringStream = Stream.empty();

        Stream stringStream = Stream.of("qwe", "asd", "zxc");
        stringStream.map(String::toUpperCase).forEach(System.out::println);

這樣會(huì)把小寫字符串全部轉(zhuǎn)成大寫。

        int[] ints = {1, 2, 3, 4, 5};
        int sum = Arrays.stream(ints).sum();

這樣會(huì)把所有的數(shù)字相加。

        /*
        /Users/cciradih/java:
        
        Java Platform, Standard Edition (Java SE) lets you develop and deploy Java applications on desktops and servers,
        as well as in today"s demanding embedded environments. Java offers the rich user interface, performance,
        versatility, portability, and security that today"s applications require.
         */


        // 不重復(fù)的單詞數(shù)
        long uniqueWords = 0;
        // 預(yù)處理獲取流，使用后不用手動(dòng)關(guān)閉流。
        try (Stream stringStream = Files.lines(Paths.get("/Users/cciradih/java"), Charset.defaultCharset())) {
            // 從流中統(tǒng)計(jì)
            uniqueWords = stringStream
                    // 扁平化字符串?dāng)?shù)組
                    .flatMap((String line) -> Arrays.stream(line.split(" ")))
                    // 去重
                    .distinct()
                    // 統(tǒng)計(jì)
                    .count();
        } catch (IOException e) {
            e.printStackTrace();
        }

這里是用到了新的 NIO，以便利用 Stream。我們使用 Files.lines 得到流，其中每個(gè)元素就是文本里的一行。然后使用 split 拆分成單詞，并用 flatMap 將其扁平化。最后用 distinct 去重再用 count 統(tǒng)計(jì)。

Stream 提供了兩個(gè)靜態(tài)方法來(lái)從函數(shù)生成流 iterate 和 gengrate。這兩個(gè)操作都可以創(chuàng)建無(wú)線流。

iterate

        Stream.iterate(0, (Integer integer) -> integer + 2);

這會(huì)創(chuàng)建一個(gè)從0開始無(wú)限的偶數(shù)流。

gengrate

        Stream.generate(Math::random);

這會(huì)創(chuàng)建一個(gè)0到1之間無(wú)限的隨機(jī)數(shù)。

這一章詳細(xì)講了流的使用場(chǎng)景和需要注意的地方，特別是和傳統(tǒng)的操作做對(duì)比，能更好地支持并行處理。

Java 8 實(shí)戰(zhàn) 第五章 使用流 讀書筆記

歡迎加入咖啡館的春天（338147322）。