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

时间 2019-11-08

原文原文链接

流让你从外部迭代转向内部迭代，for循环显示迭代不用再写了，流内部管理对集合数据的迭代。这种处理数据的方式颇有用，由于你让Stream API管理如何处理数据。这样Stream API就能够在背后进行多种优化。此外，使用内部迭代的话，Stream API能够决定并行运行你的代码。这要是用外部迭代的话就办不到了，由于你只能用单一线程挨个迭代。java

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的结果不会以任何顺序排列。dom

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卡路里):spa

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 类(java.util.Optional)是一个容器类，表明一个值存在或不存在。Optional里面几种能够迫使你显式地检查值是否存在或处理值不存在的情形的方法也不错。

isPresent()将在Optional包含值的时候返回true, 不然返回false。
ifPresent(Consumer 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 来将两个元素结合起来产生一个新值，这里咱们用的是 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 。例如，你能够像下面这样用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 类型的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

欢迎收藏和转发，感谢你的支持！(๑•̀ㅂ•́)و✧
欢迎关注个人公众号：庄里程序猿，读书笔记教程资源第一时间得到！