【Java 8实战笔记】引入流

2017-10-05 本文已影响90人谢随安

引入流

集合是Java中使用最多的API。几乎每个Java应用程序都会制造和处理集合。但集合的操作却远远算不上完美。

流是Java API，它允许你以声明性方式处理数据集合。此外流还可以透明性地并行处理，无需写任何多线程代码。

下面是一个Java 7实现的返回低热量的菜肴名称并按照卡路里排序：

List<Dish> lowCaloricDishes = new ArrayList<>();
for(Dish d: dishes){
    if(d.getCalories() < 400){
        lowCaloricDishes.add(d);
    }
}
Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
    public int compare(Dish d1, Dish d2){
        return Integer.compare(d1.getCalories(), d2.getCalories());
    }
});
List<String> lowCaloricDishesName = new ArrayList<>();
for(Dish d: lowCaloricDishes){
    lowCaloricDishesName.add(d.getName());
}

变量lowCaloricDishes唯一的作用就是作为一次性的中间容器。

下面是Java 8实现：

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toList;
List<String> lowCaloricDishesName = 
    menu.stream()
        .filter(d -> d.getCalories() < 400)
        .sorted(comparing(Dish::getCalories))
        .map(Dish::getName)
        .collect(toList());

为了利用多核架构并行执行这段代码，只需要把 stream() 换成 parallelStream() ：

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.toList;
List<String> lowCaloricDishesName = 
    menu.parallelStream()
        .filter(d -> d.getCalories() < 400)
        .sorted(comparing(Dish::getCalories))
        .map(Dish::getName)
        .collect(toList());

使用新的方法有几个显而易见的好处：

代码时以声明性方式写的
通过把几个基础操作链接起来，来表达复杂的数据处理流水线，同时保持代码清晰可读。

使用Java 8 的Stream API的优点：

声明性
可复合
可并行

流简介

流是什么？简短的定义就是“从支持数据处理操作的源生成的元素序列”。

元素序列 ----- 就像集合一样，流也提供一个接口，可以访问特定元素类型的一组有序值。
源 ----- 流会使用一个提供数据的源，如集合、数组或输入/输出资源。
数据处理操作 ----- 流的数据处理功能支持类似于数据库的操作。以及函数式编程语言中的常用操作。

此外，流操作有两个重要的特点：

流水线 ----- 很多流操作本身会返回一个流，这样多个操作就可以连接起来，形成一个大的流水线。
内部迭代 ----- 与使用迭代器显式迭代的集合不同，流的迭代操作是在背后进行的。

例如：

import static java.util.stream.Collectors.toList;
List<String> threeHighCaloricDishesName = 
    menu.stream()
        .filter(d -> d.getCalories() > 300)
        .map(Dish::getName)
        .limit(3)
        .collect(toList());
    System.out.println(threeHighCaloricDishNames);

在上面示例代码中，先是对menu调用stream方法，由菜单得到一个流。数据源是menu，它给流提供一个元素序列。接下来，对流应用一系列数据处理操作：filter、map、limit和collect。除了collect之外，所有这些操作都会返回一个流，这样就可以连接成一条流水线。最后，collect操作开始处理流水线，并返回结果（它和别的操作不一样，因为它返回的是一个List）。

在调用collect之前，没有任何结果产生，实际上根本就没有从menu里选择元素，可以理解为：链中的方法调用都在排队等待，直到调用collect。

filter ----- 接受Lambda，从流中排除某些元素。
map ----- 接受一个Lambda，将元素转换成其他形式或提取信息。
limit ----- 截断流，使其元素不超过给定数量。
collect ----- 将流转换为其他形式。

这样做的好处在于，你并没有去实现筛选、提取或截断功能，Stream库已经自带了。

流与集合

粗略的说，集合与流之间的差异就在于什么时候进行计算。集合是一个内存中的数据结构，它包含数据结构中目前所有的值，集合中每个元素都得算出来来才能添加到集合中（不管往集合里加东西或者删东西，集合中的每个元素都是放在内存里的，元素都得先算出来才能成为集合的一部分）。
流则是概念上固定的数据结构，其元素是按需计算的。从另一个角度来说，流就像是一个延迟创建的集合：只有在消费者要求的时候才会计算值。而集合则是急切创建的。

只能遍历一次

和迭代器类似，流只能遍历一次。遍历完以后，这个流就已经被消费掉了。可以从原始数据源那里再获得一个新的流来重新遍历一遍。

以下代码会抛出一个异常，提示流已被消费掉了：

List<String> title = Arrays.asList("Java8","In","Action");
Stream<String> s = title.stream();
s.forEach(System.out::println);
s.forEach(System.out::println);

外部迭代和内部迭代

集合和流的另一个关键区别在于它们遍历数据的方式。

使用Collection接口需要用户去做迭代（比如用for-each），这称为外部迭代。而Stream库使用内部迭代 ----- 它帮你把迭代做了，还把得到的流值存在了某个地方，只要给出一个函数说要干什么就可以了。

用for-each循环外部迭代：

List<String> names = new ArrayList<>();
for(Dish d: menu){
    names.add(d.getName());
}

用背后的迭代器做外部迭代：

List<String> names = new ArrayList<>();
Iterator<String> iterator =menu.iterator();
while(iterator.hasNext()) {
    Dish d = iterator.next();
    names.add(d.getName());
}

流：内部迭代：

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

流操作

java.util.stream.Stream中的stream接口定义了许多操作。它们可以被分为两大类：中间操作和终端操作。可以被连接起来的流操作称为中间操作，关闭流的操作称为终端操作。

中间操作

中间操作会返回另一个流。这让多个操作可以连接起来形成一个查询。更重要的是，除非流水线上触发一个终端操作，否则中间操作不会执行任何处理。中间操作会合并起来在终端操作时一次性全部处理。

终端操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值。

使用流

流的使用一般包括三件事：

一个数据源来执行一个查询；
一个中间操作链，形成一条流的流水线；
一个终端操作，执行流水线并生成结果。

流的流水线背后的理念类似于构建器模式。在构建器模式中有一个调用链用来设置一套配置（流的中间操作链），接着是调用built方法（流的终端操作）。