java8新特性:Stream

为什么需要 Stream

Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序。所以说，Java 8 中首次出现的 java.util.stream 是一个函数式语言+多核时代综合影响的产物。

什么是流

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。

而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方式去遍历时，每个 item 读完后再读下一个 item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。Stream 的并行操作依赖于 Java7 中引入的 Fork/Join 框架（JSR166y）来拆分任务和加速处理过程。

流的构成

当我们使用一个流的时候，通常包括三个基本步骤：

获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道，如下图所示

流的简单使用:(并发执行(parallelStream )  过滤(Stream))

public static <E> void main(String[] args) {
     List<String> list = new ArrayList<String>();
     String name=null;
     for (int i = 0; i < 1000; i++) {
    name="zhang"+i;
list.add(name);
}
  Stream<String> parallelStream = list.parallelStream();
       parallelStream.forEach(e->StreamTest.insert(e));
}


private static void insert(String name) {
System.out.println("插入"+name);
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

private class Article {            private final String title;          private final String author;          private final List<String> tags;            private Article(String title, String author, List<String> tags) {              this .title = title;              this .author = author;              this .tags = tags;          }            public String getTitle() {              return title;          }            public String getAuthor() {              return author;          }            public List<String> getTags() {              return tags;          }      }

每个例子都会包含一个使用传统循环的方案和一个使用Java 8新特性的方案。

在第一个例子里，我们要在集合中查找包含“Java”标签的第一篇文章。

看一下使用for循环的解决方案。

1 2 3 4 5 6 7 8 9 10

public Article getFirstJavaArticle() {        for (Article article : articles) {          if (article.getTags().contains( "Java" )) {              return article;          }      }        return null ; }

现在我们使用Stream API的相关操作来解决这个问题。

1 2 3 4 5

public Optional<Article> getFirstJavaArticle() {       return articles.stream()          .filter(article -> article.getTags().contains( "Java" ))          .findFirst();      }

是不是很酷？我们首先使用 filter 操作去找到所有包含Java标签的文章，然后使用 findFirst() 操作去获取第一次出现的文章。因为Stream是“延迟计算”（lazy）的并且filter返回一个流对象，所以这个方法仅在找到第一个匹配元素时才会处理元素。

现在，让我们获取所有匹配的元素而不是仅获取第一个。

首先使用for循环方案。

1 2 3 4 5 6 7 8 9 10 11 12

public List<Article> getAllJavaArticles() {        List<Article> result = new ArrayList<>();        for (Article article : articles) {          if (article.getTags().contains( "Java" )) {              result.add(article);          }      }        return result; }

使用Stream操作的方案。

1 2 3 4 5

public List<Article> getAllJavaArticles() {       return articles.stream()          .filter(article -> article.getTags().contains( "Java" ))          .collect(Collectors.toList());      }

在这个例子里我们使用 collection 操作在返回流上执行少量代码而不是手动声明一个集合并显式地添加匹配的文章到集合里。

到目前为止还不错。是时候举一些突出Stream API强大的例子了。

根据作者来把所有的文章分组。

照旧，我们使用循环方案。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public Map<String, List<Article>> groupByAuthor() {        Map<String, List<Article>> result = new HashMap<>();        for (Article article : articles) {          if (result.containsKey(article.getAuthor())) {              result.get(article.getAuthor()).add(article);          } else {              ArrayList<Article> articles = new ArrayList<>();              articles.add(article);              result.put(article.getAuthor(), articles);          }      }        return result; }

我们能否找到一个使用流操作的简洁方案来解决这个问题？

1 2 3 4

public Map<String, List<Article>> groupByAuthor() {       return articles.stream()          .collect(Collectors.groupingBy(Article::getAuthor)); }

很好！使用 groupingBy 操作和 getAuthor 方法，我们得到了更简洁、可读性更高的代码。

现在，我们查找集合中所有不同的标签。

我们从使用循环的例子开始。

1 2 3 4 5 6 7 8 9 10

public Set<String> getDistinctTags() {        Set<String> result = new HashSet<>();        for (Article article : articles) {          result.addAll(article.getTags());      }        return result; }

好，我们来看看如何使用Stream操作来解决这个问题。

1 2 3 4 5

public Set<String> getDistinctTags() {       return articles.stream()          .flatMap(article -> article.getTags().stream())          .collect(Collectors.toSet()); }

flatmap 帮我把标签列表转为一个返回流，然后我们使用 collect 去创建一个集合作为返回值。