集合操作利器-java 8中的Stream(一)

2019-02-15 本文已影响0人一路花开_8fab

一、为什么需要流(Stream)

我们简单看看使用流的好处吧。下面两段代码都是用来返回低热量的菜肴名称的，并按照卡路里排序，一个是用Java 7写的，另一个是用Java 8的流写的。比一下
之前(Java 7)

        // 筛选低热量的菜肴
        List<Dish> lowCaloricDishes = new ArrayList<>();
        for (Dish d : menu) {
            if (d.getCalories() < 400) {
                lowCaloricDishes.add(d);
            }
        }

        // 将菜肴按照卡路里进行排序
        Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
            @Override
            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 7中，我们需要显示地处理集合中元素的迭代，这种方式成为外部迭代（比如用for-each、iterator等）。
之后（Java 8）

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

而在java 8中，我们无需处理迭代的细节，只需要声明需要对集合执行的操作即可--Stream库使用内部迭代-它帮你把迭代做了。
使用Stream API可以带来哪些好处呢？
（1）代码更简洁，更易读
代码是以声明性的方式编写的:说明想要完成什么(筛选热量低的菜肴的名称 )而不是说明如何实现一个操作（利用循环和if条件等控制语句）
（2）对集合的不同操作可以灵活地组合
可以把几个基础操作链接起来，来表达复杂的数据处理流水线(在filter后面接上 sorted、map和collect操作，如下图所示)，同时保持代码清晰可读。filter的结果被传给了sorted方法，再传给map方法，最后传给collect方法。

将流操操作连接起来构成流水线.png

（3）支持并行处理，充分利用多核架构
Streams库的内部迭代可以自动选择一种适合硬件的数据表示和并行实现。在上面的例子中，为了利用多核架构并行执行代码，只需要把stream()换成parallelStream(),而无需自己去写任何多线程的代码，陷入任务和synchronized的漫长而艰苦的斗争。

  List<String> lowCaloricDishesName =
                menu.parallelStream()
                        .filter(d -> d.getCalories() < 400)
                        .sorted(comparing(Dish::getCalories))
                        .map(Dish::getName)
                        .collect(toList());

二、流与集合

集合是一个内存中的数据结构，它包含数据结构中目前所有的值，而流不是数据结构，不保存数据，它是有关算法和计算的。流更像一个高级的迭代器（Iterator），单向，只能遍历一次

三、流的使用

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

一个数据源(如集合)来执行一个查询;
一个中间操作链，形成一条流水线
一个终端操作，执行流水线，并能生成结果

流管道 (Stream Pipeline)的组成.png

3.1 如何创建流

3.1.1 由集合创建流

从上面的介绍我们可以得知，从集合创建流是最常见的创建流的方式。

Collection.stream()
Collection.parallelStream()

3.1.2 由值创建流

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

3.1.3 由数组创建流

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

3.1.4 由文件生成流

long uniqueWords = 0;
try (Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {
    uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" "))).distinct().count();
} catch (IOException e) {
}

3.1.5 由函数生成流

Stream API提了两个静态方法来从函数生成流 :Stream.iterate和Stream.generate。这两个操作可以创建所谓的无限流:不像从固定集合创建的流那样有固定大小的流。由iterate和generate产生的流会用给定的函数按需创建值，因此可以无穷无尽地计算下去!一般来说，应该使用limit(n)来对这种流加以限制，以免打印无穷多个值。

// 打印0,2,4,6,...,16,18
Stream.iterate(0, n -> n + 2)
      .limit(10)
      .forEach(System.out::println);

//  成一个流，其中有五个0到1之间的随机双精度数
Stream.generate(Math::random)
          .limit(5)
          .forEach(System.out::println);

3.2 流的操作

流的操作可以分为两大类：可以连接起来的操作称为中间操作，关闭流的操作称为终端操作。

中间操作与终端操作.png

(1) 中间操作（Intermediate）
一个流可以后面跟随零个或多个Intermediate操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
(2) 终端操作（Terminal）
一个流只能有一个Terminal操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，其结果是任何不是流的值，比如List、Integer，甚至void。
(3) 短路操作（short-circuiting）
当操作一个无限大的 Stream，而又希望在有限时间内完成操作，则在管道内拥有一个 short-circuiting 操作是必要非充分条件。

对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果。

常见的操作可以归类如下：

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

在对于一个 Stream 进行多次转换操作 (Intermediate 操作)时，每个Intermediate 操作都会循环遍历一次集合中的元素吗？其实不是这样的。下面的代码从1-10中筛选出小于10的偶数，并只取出前两个：

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        list.stream()
                .filter(i -> {
                    System.out.println(i);
                    return i < 10;
                })
                .map(i -> {
                    System.out.println(i);
                    return i * i;
                })
                .limit(1)
                .collect(Collectors.toList());

执行代码将打印：

from filter:1
from map:1
from filter:2
from map:2

可以看出，尽管filter和map是两个独立的操作，但它们合并到同一次遍历中了，我们把这种技术叫作循环合并。
转换操作都是 lazy 的，多个转换操作只会在 Terminal 操作的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream 里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在 Terminal 操作的时候循环 Stream 对应的集合，然后对每个元素执行所有的函数。

参考链接

1.Java 8 in Action
2.https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html