Java 8：不要再用循环了

正如我之前所写的，Java 8中的新功能特性改变了游戏规则。对Java开发者来说这是一个全新的世界，并且是时候去适应它了。

在这篇文章里，我们将会去了解传统循环的一些替代方案。在Java 8的新功能特性中，最棒的特性就是允许我们去表达我们想要完成什么而不是要怎样做。这正是循环的不足之处。要确保循环的灵活性是需要付出代价的。return、break 或者 continue都会显著地改变循环的实际表现。这迫使我们不仅要清楚我们要实现怎样的代码，还要了解循环是怎样工作的。

在介绍Java 8的流（Stream）时，我们学会了一些集合操作的实用技巧。现在我们要看看怎样把这些循环转换为更简洁，可读性更高的代码。

开始编码！

好吧，讲的够多了，是时候展示一些例子了！

这次我们要以文章为例子。一篇文章拥有一个标题，一个作者和几个标签。

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;
        }
 
        publicString getTitle() {
            returntitle;
        }
 
        publicString getAuthor() {
            returnauthor;
        }
 
        publicList<String> getTags() {
            returntags;
        }
    }

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

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

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

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

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

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

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

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

首先使用for循环方案。

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

使用Stream操作的方案。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

一切皆有可能

以上的就是如何使用可读性更高的代码代替循环的例子。务必仔细看看Stream API，因为这篇文章仅仅提到它的一些皮毛而已。

刚开始用java8的时候，很多都是替代for循环，因为java8推出了强大的流stream，关于流的用法很多，百度一下就可以搜到语法之类，所以这里我只想举一些简单替代for的例子，含义那些就自己去查吧。 
好了，让我们开始吧。男人类有很多卡类，先初始化一些数据。

List<Man> mans = new ArrayList<>();
        mans.add(new Man("001","张三",Arrays.asList(new Card("工商银行","9558800001"),new Card("工商银行","9558800002"),new Card("建设银行","6227001234"))));
        mans.add(new Man("002","李四",Arrays.asList(new Card("招商银行","6225800002"),new Card("建设银行","6227035248"))));
        mans.add(new Man("003","王五",Arrays.asList(new Card("建设银行","6227056547"),new Card("中国银行","6013832547"),new Card("民生银行","4074058542"))));
        mans.add(new Man("004","赵六",Arrays.asList(new Card("工商银行","9558832458"),new Card("工商银行","9558832547"),new Card("建设银行","6227032578"))));
        mans.add(new Man("005","孙七",Arrays.asList(new Card("中国银行","6013825847"),new Card("农业银行","6228836547"),new Card("招商银行","6225014582"))));
        mans.add(new Man("006","张三",Arrays.asList(new Card("工商银行","9558832587"),new Card("交通银行","6222814578"),new Card("工商银行","9558865427"))));

1，查找张三的男人，for是这样的，

public List<Man> getByName(List<Man> mans){
        List<Man> temp = new ArrayList<>();
        for(Man man : mans){
            if("张三".equals(man.getName())){
                temp.add(man);
            }
        }
        return temp;
    }

改进后为：

public List<Man> getByName8(List<Man> mans) {
        return mans.stream().filter(m -> "张三".equals(m.getName())).collect(Collectors.toList());
    }

这里的集合相当与数据库的表，而filter相当于数据库的where。 
2，继续，查找id为007的男人，id唯一，for是这样的

public List<Man> getByName8(List<Man> mans) {
        return mans.stream().filter(m -> "张三".equals(m.getName())).collect(Collectors.toList());
    }

改进后为:

public Man getById8(List<Man> mans) {
        return mans.stream().filter(m -> "oo7".equals(m.getId())).findFirst().orElse(null);
    }

3，继续，获取名字叫张三（因有同名）的所有银行卡，这里不讨论实际业务意义，只讲技术，哈哈，用for是这样的。

public List<Card> getAllCardByName(List<Man> mans) {
        List<Card> cards = new ArrayList<>();
        for (Man man : mans) {
            if ("张三".equals(man.getName())) {
                cards.addAll(man.getCards());
            }
        }
        return cards;
    }

改进后是这样的

public List<Card> getAllCardByName8(List<Man> mans) {
        return mans.stream().filter(m -> "张三".equals(m.getName())).flatMap(m -> m.getCards().stream())
                .collect(Collectors.toList());
    }

4，继续，在3的条件上加个工商银行条件，for

public List<Card> getSomeCardByName(List<Man> mans) {
        List<Card> cards = new ArrayList<>();
        for (Man man : mans) {
            if ("张三".equals(man.getName())) {
                for (Card card : man.getCards()) {
                    if ("工商银行".equals(card.getName())) {
                        cards.add(card);
                    }
                }
            }
        }
        return cards;
    }

改进后是这样的

public List<Card> getSomeCardByName8(List<Man> mans) {
        return mans.stream().filter(m -> "张三".equals(m.getName())).flatMap(m -> m.getCards().stream())
                .filter(c -> "工商银行".equals(c.getName())).collect(Collectors.toList());
    }

5，把张三的名字修改为新张三，for，注意会改变源数据

public List<Card> getSomeCardByName8(List<Man> mans) {
        return mans.stream().filter(m -> "张三".equals(m.getName())).flatMap(m -> m.getCards().stream())
                .filter(c -> "工商银行".equals(c.getName())).collect(Collectors.toList());
    }

改进：

public List<Man> changeName8(List<Man> mans) {
        return mans.stream().peek(m -> {
            if ("张三".equals(m.getName()))
                m.setName("新张三");
        }).collect(Collectors.toList());
    }

先这样。