《Java 8 in Action》Chapter 5：使用流

流讓你從外部迭代轉向內部迭代，for循環顯示迭代不用再寫了，流內部管理對集合數據的迭代。這種處理數據的方式頗有用，由於你讓Stream API管理如何處理數據。這樣Stream API就能夠在背後進行多種優化。此外，使用內部迭代的話，Stream API能夠決定並行運行你的代碼。這要是用外部迭代的話就辦不到了，由於你只能用單一線程挨個迭代。

1. 篩選和切片

1.1 用謂詞篩選

該操做會接受一個謂詞(一個返回 boolean的函數)做爲參數，並返回一個包括全部符合謂詞的元素的流。篩選出全部素菜

List<Dish> vegetarianMenu = menu.stream()
                                .filter(Dish::isVegetarian)
                                .collect(toList());

1.2 篩選各異的元素

返回一個元素各異(根據流所生成元素的 hashCode和equals方法實現)的流。篩選出列表中全部的偶數，並確保沒有重複。

List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
        .filter(i -> i % 2 == 0)
        .distinct()
        .forEach(System.out::println);

1.3 截短流

流支持limit(n)方法，該方法會返回一個不超過給定長度的流。所需的長度做爲參數傳遞給limit。若是流是有序的，則最多會返回前n個元素。選出熱量超過300卡路里的頭三道菜

List<Dish> dishes = menu.stream()
                        .filter(d -> d.getCalories() > 300)
                        .limit(3)
                        .collect(toList());

limit也能夠用在無序流上，好比源是一個Set。這種狀況下，limit的結果不會以 任何順序排列。

1.4 跳過元素

流還支持skip(n)方法，返回一個扔掉了前n個元素的流。若是流中元素不足n個，則返回一個空流。跳過超過300卡路里的頭兩道菜，並返回剩下的。

List<Dish> dishes = menu.stream()
                        .filter(d -> d.getCalories() > 300)
                        .skip(2)
                        .collect(toList());

2. 映射

2.1 對流中每個元素應用函數

流支持map方法，它會接受一個函數做爲參數。這個函數會被應用到每一個元素上，並將其映射成一個新的元素。提取流中菜餚的名稱：

List<String> dishNames = menu.stream()
                             .map(Dish::getName)
                             .collect(toList());

2.2 流的扁平化

flatmap方法讓你把一個流中的每一個值都換成另外一個流，而後把全部的流鏈接起來成爲一個流。單個流都被合併起來，即扁平化爲一個流。例如，給定單詞列表 ["Hello","World"]，你想要返回列表["H","e","l", "o","W","r","d」]。

List<String> words = Arrays.asList("Java 8", "Lambdas", "In", "Action」);
List<String> uniqueCharacters = words.stream()
         .map(w -> w.split(""))
         .flatMap(Arrays::stream)
         .distinct()
         .collect(Collectors.toList());

3. 查找和匹配

3.1 檢查謂詞是否至少匹配一個元素

anyMatch方法能夠回答「流中是否有一個元素能匹配給定的謂詞」。anyMatch方法返回一個boolean，所以是一個終端操做。好比，你能夠用它來看看菜單裏面是否有素食可選擇:

if(menu.stream().anyMatch(Dish::isVegetarian)){
System.out.println("The menu is (somewhat) vegetarian friendly!!");
}

3.2 檢查謂詞是否匹配全部元素

allMatch方法的工做原理和anyMatch相似，但它會看看流中的元素是否都能匹配給定的謂詞。好比，你能夠用它來看看菜品是否有利健康(即全部菜的熱量都低於1000卡路里):

boolean isHealthy = menu.stream().allMatch(d -> d.getCalories() < 1000);

和allMatch相對的是noneMatch。它能夠確保流中沒有任何元素與給定的謂詞匹配。好比， 你能夠用noneMatch重寫前面的例子:

boolean isHealthy = menu.stream().noneMatch(d -> d.getCalories() >= 1000);

anyMatch、allMatch和noneMatch這三個操做都用到了咱們所謂的短路，這就是你們熟悉 的Java中&&和||運算符短路在流中的版本。

3.3 查找元素

findAny方法將返回當前流中的任意元素。它能夠與其餘流操做結合使用。好比，你可能想找到一道素食菜餚。你能夠結合使用filter和findAny方法來實現這個查詢:

Optional<Dish> dish =menu.stream()
            .filter(Dish::isVegetarian)
            .findAny();

Optional<T>類(java.util.Optional)是一個容器類，表明一個值存在或不存在。Optional裏面幾種能夠迫使你顯式地檢查值是否存在或處理值不存在的情形的方法也不錯。

• isPresent()將在Optional包含值的時候返回true, 不然返回false。
• ifPresent(Consumer<T> block)會在值存在的時候執行給定的代碼塊。
• T get()會在值存在時返回值，不然拋出一個NoSuchElement異常。
• T orElse(T other)會在值存在時返回值，不然返回一個默認值。

3.4 查找第一個元素

爲此有一個findFirst 方法，它的工做方式相似於findany。 例如，給定一個數字列表，下面的代碼能找出第一個平方 能被3整除的數:

List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstSquareDivisibleByThree = someNumbers.stream()
                                                           .map(x -> x * x)
                                                           .filter(x -> x % 3 == 0)
                                                           .findFirst(); // 9

4. 歸約

歸約操做 (將流歸約成一個值)。用函數式編程語言的術語來講，這稱爲摺疊(fold)，由於你能夠將這個操做當作把一張長長的紙(你的流)反覆摺疊成一個小方塊，而這就是摺疊操做的結果。

4.1 元素求和

reduce操做是如何做用於一個流的:Lambda反覆結合每一個元素，直到流被歸約成一個值。
reduce接受兩個參數:

• 一個初始值，這裏是0;
• 一個BinaryOperator<T>來將兩個元素結合起來產生一個新值，這裏咱們用的是 lambda (a, b) -> a + b。

int sum = numbers.stream().reduce(0, (a, b) -> a + b);

reduce還有一個重載的變體，它不接受初始值，可是會返回一個Optional對象:

Optional<Integer> sum = numbers.stream().reduce((a, b) -> (a + b));

4.2 最大值和最小值

使用reduce來計算流中的最大值

Optional<Integer> max = numbers.stream().reduce(Integer::max);

要計算最小值，你須要把Integer.min傳給reduce來替換Integer.max:

Optional<Integer> min = numbers.stream().reduce(Integer::min);

4.3 小結

5. 實戰

public class ExecDemo {
    public static void main(String[] args) {
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario","Milan");
        Trader alan = new Trader("Alan","Cambridge");
        Trader brian = new Trader("Brian","Cambridge");
        List<Transaction> transactions = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
        );

        System.out.println("(1) 找出2011年發生的全部交易，並按交易額排序(從低到高)。");
        List<Transaction> collect = transactions.stream()
                .filter(t -> t.getYear() == 2011)
                .sorted(Comparator.comparing(Transaction::getValue))
                .collect(Collectors.toList());
        System.out.println(collect);

        System.out.println("\n(2) 交易員都在哪些不一樣的城市工做過?");
        List<String> collect1 = transactions.stream()
                .map(transaction -> transaction.getTrader().getCity())
                .distinct()
                .collect(Collectors.toList());
        System.out.println(collect1);
        // [Cambridge, Milan]

        System.out.println("\n(3) 查找全部來自於劍橋的交易員，並按姓名排序。");
        List<Trader> collect2 = transactions.stream()
                .map(Transaction::getTrader)
                .filter(trader -> trader.getCity().equals("Cambridge"))
                .distinct()
                .sorted(Comparator.comparing(Trader::getName))
                .collect(Collectors.toList());
        System.out.println(collect2);

        System.out.println("\n(4) 返回全部交易員的姓名字符串，按字母順序排序。");
        String reduce = transactions.stream()
                .map(transaction -> transaction.getTrader().getName())
                .distinct()
                .sorted()
                .reduce("", (n1, n2) -> n1 + n2);
        System.out.println(reduce);

        System.out.println("\n(5) 有沒有交易員是在米蘭工做的?");
        boolean b = transactions.stream()
                .anyMatch(transaction -> transaction.getTrader().getCity().equals("Milan"));
        System.out.println(b);

        System.out.println("\n(6) 打印生活在劍橋的交易員的全部交易額。");
        transactions.stream()
                .filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getValue)
                .forEach(System.out::println);

        System.out.println("\n(7) 全部交易中，最高的交易額是多少?");
        transactions.stream()
                .map(Transaction::getValue)
                .reduce(Integer::max)
                .ifPresent(System.out::println);

        System.out.println("\n(8) 找到交易額最小的交易。");
        transactions.stream()
                .map(Transaction::getValue)
                .reduce(Integer::min)
                .ifPresent(System.out::println);
    }

6. 數值流

6.1 原始類型流特化

Java 8引入了三個原始類型特化流接口來解決這個問題:IntStream、DoubleStream和 LongStream，分別將流中的元素特化爲int、long和double，從而避免了暗含的裝箱成本。

6.1.1 映射到數值流

將流轉換爲特化版本的經常使用方法是mapToInt、mapToDouble和mapToLong。這些方法和前 面說的map方法的工做方式同樣，只是它們返回的是一個特化流，而不是Stream<T>。例如，你 能夠像下面這樣用mapToInt對menu中的卡路里求和:

int calories = menu.stream()                        // 返回一個 Stream<Dish>
                    .mapToInt(Dish::getCalories)    // 返回一個 IntStream
                    .sum();

請注意，若是流是空的，sum默認返回0。IntStream還支持其餘的方便方法，如max、min、average等。

6.1.2 轉換回對象流

要把原始流轉換成通常流(每一個int都會裝箱成一個 Integer)，可使用boxed方法，以下所示:

IntStream intStream = menu.stream().mapToInt(Dish::getCalories); //將Stream轉換爲數值流
Stream<Integer> stream = intStream.boxed(); // 將數值流轉換爲Stream

6.1.3 默認值OptionalInt

對於三種原始流特化，也分別有一個Optional原始類 型特化版本:OptionalInt、OptionalDouble和OptionalLong。例如，要找到IntStream中的最大元素，能夠調用max方法，它會返回一個OptionalInt:

OptionalInt maxCalories = menu.stream().mapToInt(Dish::getCalories).max();

6.2 數值範圍

Java 8引入了兩個能夠用於IntStream和LongStream的靜態方法，幫助生成這種範圍: range和rangeClosed。這兩個方法都是第一個參數接受起始值，第二個參數接受結束值。但range是不包含結束值的，而rangeClosed則包含結束值。

IntStream evenNumbers = IntStream.range(1, 100) .filter(n -> n % 2 == 0); // 一個從1到100的偶數流   表示範圍[1, 100)
IntStream evenNumbers = IntStream.rangeClosed(1, 100) .filter(n -> n % 2 == 0); // 一個從1到100的偶數流   表示範圍[1, 100]

7. 構建流

7.1 由值建立流

你可使用靜態方法Stream.of，經過顯式值建立一個流。它能夠接受任意數量的參數。例如，如下代碼直接使用Stream.of建立了一個字符串流。而後，你能夠將字符串轉換爲大寫，再一個個打印出來:

Stream<String> stream = Stream.of("Java 8 ", "Lambdas ", "In ", "Action"); 
stream.map(String::toUpperCase).forEach(System.out::println);

你可使用empty獲得一個空流，以下所示:

Stream<String> emptyStream = Stream.empty();

7.2 由數組建立流

你可使用靜態方法Arrays.stream從數組建立一個流。它接受一個數組做爲參數。例如，你能夠將一個原始類型int的數組轉換成一個IntStream，以下所示:

int[] numbers = {2, 3, 5, 7, 11, 13}; 
int sum = Arrays.stream(numbers).sum();

7.3 由文件生成流

Java中用於處理文件等I/O操做的NIO API(非阻塞 I/O)已更新，以便利用Stream API。 java.nio.file.Files中的不少靜態方法都會返回一個流。例如，一個頗有用的方法是 Files.lines，它會返回一個由指定文件中的各行構成的字符串流。

7.4 由函數生成流:建立無限流

Stream API提供了兩個靜態方法來從函數生成流:Stream.iterate和Stream.generate。 這兩個操做能夠建立所謂的無限流:不像從固定集合建立的流那樣有固定大小的流。由iterate 2 和generate產生的流會用給定的函數按需建立值，所以能夠無窮無盡地計算下去!通常來講， 應該使用limit(n)來對這種流加以限制，以免打印無窮多個值。

7.4.1 迭代

Stream.iterate(0, n -> n + 2)
      .limit(10)
      .forEach(System.out::println);

此操做將生成一個無限流——這個流沒有結尾，由於值是按需計算的，能夠永遠計算下去。咱們說這個流是無界的。正如咱們前面所討論的，這是流和集合之間的一個關鍵區別。咱們使用limit方法來顯式限制流的大小。這裏只選擇了前10個偶數。而後能夠調用forEach終端操做來消費流，並分別打印每一個元素。

7.4.2 生成

與iterate方法相似，generate方法也可以讓你按需生成一個無限流。但generate不是依次 對每一個新生成的值應用函數的。它接受一個Supplier<T>類型的Lambda提供新的值。咱們先來看一個簡單的用法:這段代碼將生成一個流，其中有五個0到1之間的隨機雙精度數。

Stream.generate(Math::random)
          .limit(5)
          .forEach(System.out::println);

8. 小結

這一章很長，可是頗有收穫!如今你能夠更高效地處理集合了。事實上，流讓你能夠簡潔地表達複雜的數據處理查詢。此外，流能夠透明地並行化。如下是你應從本章中學到的關鍵概念。

• Streams API能夠表達複雜的數據處理查詢。經常使用的流操做總結在表5-1中。
• 你可使用filter、distinct、skip和limit對流作篩選和切片。
• 你可使用map和flatMap提取或轉換流中的元素。
• 你可使用findFirst和findAny方法查找流中的元素。你能夠用allMatch、noneMatch和anyMatch方法讓流匹配給定的謂詞。
• 這些方法都利用了短路:找到結果就當即中止計算;沒有必要處理整個流。
• 你能夠利用reduce方法將流中全部的元素迭代合併成一個結果，例如求和或查找最大元素。
• filter和map等操做是無狀態的，它們並不存儲任何狀態。reduce等操做要存儲狀態才能計算出一個值。sorted和distinct等操做也要存儲狀態，由於它們須要把流中的全部元素緩存起來才能返回一個新的流。這種操做稱爲有狀態操做。
• 流有三種基本的原始類型特化:IntStream、DoubleStream和LongStream。它們的操做也有相應的特化。
• 流不只能夠從集合建立，也可從值、數組、文件以及iterate與generate等特定方法建立。
• 無限流是沒有固定大小的流。

資源獲取

• 公衆號回覆 : Java8 便可獲取《Java 8 in Action》中英文版!

Tips

• 歡迎收藏和轉發，感謝你的支持！(๑•̀ㅂ•́)و✧
• 歡迎關注個人公衆號：莊裏程序猿，讀書筆記教程資源第一時間得到！