跟我学 Java 8 新特性之 Stream 流（六）收集

转载自跟我学 Java 8 新特性之 Stream 流（六）收集

我们前面的五篇文章基本都是在说将一个集合转成一个流，然后对流进行操作，其实这种操作是最多的，但有时候我们也是需要从流中收集起一些元素，并以集合的方式返回，我们把这种反向操作称为收集。

流API也给我们提供了相应的方法。

如何在流中使用收集功能？

我们先看一看流API给我们提供的方法：

public interface Stream<T> extends BaseStream<T, Stream<T>> {//...忽略那些不重要的东西<R> R collect(Supplier<R> supplier,BiConsumer<R, ? super T> accumulator,BiConsumer<R, R> combiner);<R, A> R collect(Collector<? super T, A, R> collector);｝

流API中给我们提供了两种，我给大家分析一下。

R collect(Collector collector);

其中R指定结果的类型，T指定了调用流的元素类型。内部积累的类型由A指定。collectorFunc是一个收集器，指定收集过程如何执行，collect()方法是一个终端方法。

虽然我们基本上很少会用到自定义的collectorFunc,但是了为扩展大家的知识面，我们还是简单地聊一聊Collector，Because it's my style!

Collector接口位于 java.util.stream包中的声明，它的容颜是这样的：

package java.util.stream;public interface Collector<T, A, R> {Supplier<A> supplier();BiConsumer<A, T> accumulator();BinaryOperator<A> combiner();Function<A, R> finisher();}

其中T、A、R的含义和上面是一样的 其中R指定结果的类型，T指定了调用流的元素类型。内部积累的类型由A指定。

但是这一篇我们不实现他们，因为JDK已经给我们提供了很强大的方法了，他们位于 java.util.stream下面的 Collectors类，我们本篇也主要是使用 Collectors来实现收集的功能。

Collectors类是一个最终类，里面提供了大量的静态的收集器方法，借助他，我们基本可以实现各种复杂的功能了。

我们来看一下toList和toSet方法:

public static <T>  Collector<T, ?, List<T>> toList()public static <T> Collector<T, ?, Set<T>> toSet()

其中 Collectors#toList()返回的收集器可以把流中元素收集到一个List中， Collectors#toSet()返回的收集器可以把流中的元素收集到一个Set中。比如：如果你想把元素收集到List中，你可以这样用， steam.collect(Collectors.toList)。

接下来，我们把我们的王者荣耀团队经济例子修改一下，把明星玩家和当前获得的金币数收集到一个List里面，把出场的英雄收集到一个Set里面：

#玩家使用的英雄以及当前获得的金币数
public class HeroPlayerGold {/** 使用的英雄名字 */private String hero;/** 玩家的ID */private String player;/** 获得的金币数 */private int gold;public HeroPlayerGold(String hero, String player, int gold) {this.hero = hero;this.player = player;this.gold = gold;}@Overridepublic String toString() {return "HeroPlayerGold{" +"hero='" + hero + '\'' +", player='" + player + '\'' +", gold=" + gold +'}';}
//省略get/set}#出场的英雄
public class Hero {/** 使用的英雄名字 */private String hero;public Hero(String hero) {this.hero = hero;}@Overridepublic String toString() {return "Hero{" +"hero='" + hero + '\'' +'}';}
//省略get/set
}#测试类
public class Main {public static void main(String[] args) {learnCollect();}private static void learnCollect() {List<HeroPlayerGold> lists = new ArrayList<>();lists.add(new HeroPlayerGold("盖伦", "RNG-Letme", 100));lists.add(new HeroPlayerGold("诸葛亮", "RNG-Xiaohu", 300));lists.add(new HeroPlayerGold("露娜", "RNG-MLXG", 300));lists.add(new HeroPlayerGold("狄仁杰", "RNG-UZI", 500));lists.add(new HeroPlayerGold("牛头", "RNG-Ming", 500));List<PlayerGold> playerGolds = lists.stream().map(plary -> new PlayerGold(plary.getPlayer(), plary.getGold())).collect(Collectors.toList());System.out.println("============PlayerGold begin==============");playerGolds.forEach(System.out::println);System.out.println("============PlayerGold end================\n");Set<Hero> heroes = lists.stream().map(player -> new Hero(player.getHero())).collect(Collectors.toSet());System.out.println("============Hero begin==============");heroes.forEach(System.out::println);System.out.println("============Hero end================");}}

输出的日志：

============PlayerGold begin==============
PlayerGold{player='RNG-Letme', gold=100}
PlayerGold{player='RNG-Xiaohu', gold=300}
PlayerGold{player='RNG-MLXG', gold=300}
PlayerGold{player='RNG-UZI', gold=500}
PlayerGold{player='RNG-Ming', gold=500}
============PlayerGold end================
============Hero begin==============
Hero{hero='露娜'}
Hero{hero='牛头'}
Hero{hero='盖伦'}
Hero{hero='狄仁杰'}
Hero{hero='诸葛亮'}
============Hero end================

看到这里，大家有感受到流API的威力了吗？提示一下，封装一个工具类，然后结合一FastJson这种东西一起使用！是真的好用啊！其实将数据从集合移到流中，或者将数据从流移回集合的能力，是流API给我们提供的一个强大特性，因为这允许通过流来操作集合，然后把流重新打包成集合。此外，条件合适的时候，让流操作并行发生，提高效率。

接下来我们分析第二个方法，

<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);

我们第二个版本的收集方法，主要是可以在收集的过程中，给予更多的控制。其中supplier指定如何创建用于保存结果的对象，比如，要使用ArrayList作为结果的集合，需要指定它的构造函数，accumulator函数是将一个元素添加到结果中，而combiner函数合并两个部分的结果。

大家应该发现了吧，他的工作方式和我们第三篇介绍缩减操作时的reduce方法是很像的。它们都必须是无状态和不干预的，并且必须有关联性，三个约束条件缺一不可。

Supplier也是 java.util.function包中的一个函数式接口:

@FunctionalInterface
public interface Supplier<T> {T get();
}

只有一个get()，并且是没有参数的，在collect()方法返回一个R类型的对象，并且get()方法返回一个指向集合的引用。

而accumulator,combiner的类型是 BiConsumer，他们也是 java.util.function包中的一个函数式接口:

@FunctionalInterface
public interface BiConsumer<T, U> {void accept(T t, U u);
}

其中t,u执行某种类型的操作，对于accumulator来说，t指定了目标集合，u指定了要添加到该集合的元素。对于combiner来说，t和u指定的是两个要被合并的集合。

我们把前面的例子改变一下，然后也详细地说一下，在没有用lambda和使用lambda之后的区别：

这个是没有使用lambda前的：

private static void learnCollect() {List<HeroPlayerGold> lists = new ArrayList<>();lists.add(new HeroPlayerGold("盖伦", "RNG-Letme", 100));lists.add(new HeroPlayerGold("诸葛亮", "RNG-Xiaohu", 300));lists.add(new HeroPlayerGold("露娜", "RNG-MLXG", 300));lists.add(new HeroPlayerGold("狄仁杰", "RNG-UZI", 500));lists.add(new HeroPlayerGold("牛头", "RNG-Ming", 500));lists.stream().collect(new Supplier<HashSet<HeroPlayerGold>>() {@Overridepublic HashSet<HeroPlayerGold> get() {return new HashSet<>();}},//第一个参数new BiConsumer<HashSet<HeroPlayerGold>, HeroPlayerGold>() {@Overridepublic void accept(HashSet<HeroPlayerGold> heroPlayerGolds, HeroPlayerGold heroPlayerGold) {heroPlayerGolds.add(heroPlayerGold);}},//第二个参数new BiConsumer<HashSet<HeroPlayerGold>, HashSet<HeroPlayerGold>>() {@Overridepublic void accept(HashSet<HeroPlayerGold> heroPlayerGolds, HashSet<HeroPlayerGold> heroPlayerGolds2) {heroPlayerGolds.addAll(heroPlayerGolds2);}}//第三个参数).forEach(System.out::println);}

在没有使用lambda前，虽然看起来的让人眼花缭乱的，但不得不说，他其实能帮助我们实现非常强大的功能，我们自定义的收集过程，全部都可以交给这个家伙，我们用lambda整理一下：

private static void learnCollect() {List<HeroPlayerGold> lists = new ArrayList<>();lists.add(new HeroPlayerGold("盖伦", "RNG-Letme", 100));lists.add(new HeroPlayerGold("诸葛亮", "RNG-Xiaohu", 300));lists.add(new HeroPlayerGold("露娜", "RNG-MLXG", 300));lists.add(new HeroPlayerGold("狄仁杰", "RNG-UZI", 500));lists.add(new HeroPlayerGold("牛头", "RNG-Ming", 500));lists.stream().collect(() -> new HashSet<>(),(set,elem)->set.add(elem),(setA,setB)->setA.addAll(setB)).forEach(System.out::println);}大家以为到这里就结束了吗？其实还可以使用方法引用和构造函数引用来简化：
private static void learnCollect() {List<HeroPlayerGold> lists = new ArrayList<>();lists.add(new HeroPlayerGold("盖伦", "RNG-Letme", 100));lists.add(new HeroPlayerGold("诸葛亮", "RNG-Xiaohu", 300));lists.add(new HeroPlayerGold("露娜", "RNG-MLXG", 300));lists.add(new HeroPlayerGold("狄仁杰", "RNG-UZI", 500));lists.add(new HeroPlayerGold("牛头", "RNG-Ming", 500));lists.stream().collect(HashSet::new,HashSet::add,HashSet::addAll).forEach(System.out::println);
}

小结一下

本篇带大家入门了Stream的收集操作，但是有了些这入门操作，我相信，你在我的演变过程中已经发现了扩展点了，不管是supplier，accumulator还是combiner，都可以在里面放一些特别的操作进去，从而满足你们的各种要求。

另外一个点，大家一定不要忘记了Collectors这个最终类，里面已经提供了很多很强大的静态方法，如果你们遇到一些特别的需求，首先要想到的应该是Collectors，如果里面的方法都不能实现你的要求，再考虑通过第二个版本的collect()方法实现你的自定义收集过程吧。

跟我学 Java 8 新特性之 Stream 流（六）收集相关推荐

跟我学 Java 8 新特性之 Stream 流（七）流与迭代器，流系列大结局
转载自跟我学 Java 8 新特性之 Stream 流(七)流与迭代器,流系列大结局恭喜你们,马上就要学完Java8 Stream流的一整系列了,其实我相信Stream流对很多使用Java的同 ...
跟我学 Java 8 新特性之 Stream 流基础体验
转载自跟我学 Java 8 新特性之 Stream 流基础体验 Java8新增的功能中,要数lambda表达式和流API最为重要了.这篇文章主要介绍流API的基础,也是流API系列的第一篇文章, ...
跟我学 Java 8 新特性之 Stream 流（二）关键知识点
转载自跟我学 Java 8 新特性之 Stream 流(二)关键知识点我们的第一篇文章,主要是通过一个Demo,让大家体验了一下使用流API的那种酣畅淋漓的感觉.如果你没有实践,我还是再次呼吁 ...
跟我学 Java 8 新特性之 Stream 流（三）缩减操作
转载自跟我学 Java 8 新特性之 Stream 流(三)缩减操作和前面两篇文章一起服用,效果会更佳.通过对流API的基础体验Demo和关键知识点的讲解,相信大家对流API都有一定的认识了, ...
跟我学 Java 8 新特性之 Stream 流（四）并行流
转载自跟我学 Java 8 新特性之 Stream 流(四)并行流随着对流API认识的慢慢深入,本章我们要讨论的知识点是流API里面的并行流了. 在开始讨论并行流之前,我先引发一下大家的思考, ...
跟我学 Java 8 新特性之 Stream 流（五）映射
转载自跟我学 Java 8 新特性之 Stream 流(五)映射经过了前面四篇文章的学习,相信大家对Stream流已经是相当的熟悉了,同时也掌握了一些高级功能了,如果你之前有阅读过集合框架的基 ...
Java 8 新特性之 Stream 流（五）映射
经过了前面四篇文章的学习,相信大家对Stream流已经是相当的熟悉了,同时也掌握了一些高级功能了,如果你之前有阅读过集合框架的基石Collection接口,是不是在经过前面的学习,以前看不懂的东西,突 ...
Java 8 新特性之Stream API
1. 概述 1.1 简介 Java 8 中有两大最为重要的改革,第一个是 Lambda 表达式,另外一个则是 Stream API(java.util.stream.*). Stream 是 Java ...
java 新特性之 stream 流
java 新特性之 stream 流 Java 8 API添加了一个新的抽象称为流Stream,可以让你以一种声明的方式处理数据. 这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在 ...

跟我学 Java 8 新特性之 Stream 流（六）收集

跟我学 Java 8 新特性之 Stream 流（六）收集相关推荐

最新文章

热门文章