文档章节

归约与分组 - 读《Java 8实战》

yysue
 yysue
发布于 2018/08/16 13:27
字数 2542
阅读 43
收藏 3

区分Collection,Collector和collect

代码中用到的类与方法用红框标出,可从git库中查看

收集器用作高级归约

// 按货币对交易进行分组
Map<Currency, List<Transaction>> currencyListMap = getTransactions().stream()
    .collect(groupingBy(Transaction::getCurrency));
for (Map.Entry<Currency, List<Transaction>> entry : currencyListMap.entrySet()) {
    System.out.println(entry.getKey() + "\t" + entry.getValue().size());
}

预定义收集器的功能

  • 将流元素归约和汇总为一个值

  • 元素分组

  • 元素分区,分组的特殊情况,使用谓词作为分组函数(谓词,返回boolean类型的函数)

Collectorsors类的静态工厂方法一览

// import static java.util.stream.Collectors.*;
Stream<Dish> menuStream = getMenu().stream();

// Collectors类的静态工厂方法
List<Dish> dishes1 = 
    menuStream.collect(toList());
Set<Dish> dishes2 = 
    menuStream.collect(toSet());
Collection<Dish> dishes3 = 
    menuStream.collect(toCollection(ArrayList::new));
long howManyDishes = 
    menuStream.collect(counting());
int totalCalories = 
    menuStream.collect(summingInt(Dish::getCalories));
double avgCalories = 
    menuStream.collect(averagingInt(Dish::getCalories));
IntSummaryStatistics menuStatistics = 
    menuStream.collect(summarizingInt(Dish::getCalories));
String shortMenu = 
    menuStream.map(Dish::getName).collect(joining(", "));
Optional<Dish> fattest = 
    menuStream.collect(maxBy(comparingInt(Dish::getCalories)));
Optional<Dish> lightest = 
    menuStream.collect(minBy(comparingInt(Dish::getCalories)));
int totalCalories2 = 
    menuStream.collect(reducing(0, Dish::getCalories, Integer::sum));
int howManyDishes2 = 
    menuStream.collect(collectingAndThen(toList(), List::size));
Map<Dish.Type,List<Dish>> dishesByType = 
    menuStream.collect(groupingBy(Dish::getType));
Map<Boolean,List<Dish>> vegetarianDishes = 
    menuStream.collect(partitioningBy(Dish::isVegetarian));

归约和汇总

汇总是归约的一种特殊情况

汇总

菜单中有多少种菜

// 菜单里有多少种菜
long howManyDishes = getMenu().stream().collect(Collectors.counting());
System.out.println(howManyDishes); // 8
long howManyDishes2 = getMenu().stream().count();
System.out.println(howManyDishes2); // 8
System.out.println(getMenu().size()); // 8,这样不是更简单??

最大值,最小值和平均值

// 菜单中热量最高的菜
Optional<Dish> mostCalaorieDish = 		 
    getMenu().stream().collect(maxBy(comparingInt(Dish::getCalories)));
System.out.println(mostCalaorieDish.orElse(null)); // pork
// 菜单中热量最低的菜
Optional<Dish> leastCalaorieDish = 
    getMenu().stream().collect(minBy(comparingInt(Dish::getCalories)));
System.out.println(leastCalaorieDish.orElse(null)); //season
// 菜单中总热量
int totalCalories = 
    getMenu().stream().collect(summingInt(Dish::getCalories));
System.out.println(totalCalories); // 3850
// 菜单中的平均热量
OptionalDouble averageCalories = 
    getMenu().stream().mapToDouble(Dish::getCalories).average();
System.out.println(averageCalories.orElse(0d)); // 481.25

一个综合的方法:求count,sum,min,average,max

// 以上汇总数据可用下面一个方法执行
IntSummaryStatistics menuStatistics = getMenu().stream().collect(summarizingInt(Dish::getCalories));
System.out.println(menuStatistics);
// IntSummaryStatistics{count=8, sum=3850, min=120, average=481.250000, max=800}

连接字符串joining

// 连接字符串
String shortMenu = getMenu().stream()
    .map(Dish::getName) // 省略这步,返回Dish的toString
    .collect(joining());
System.out.println(shortMenu); 
// porkchickenfrench friesriceseasonpizzaprawnssalmon

// 逗号分隔
String shortMenu2 = getMenu().stream()
    .map(Dish::getName)
    .collect(joining(", "));
System.out.println(shortMenu2); 
// pork, chicken, french fries, rice, season, pizza, prawns, salmon

广义的汇总:归约

所有收集器,都是一个可以用reducing工厂方法定义的归约过程的特殊情况而已。 Collectors.reducing工厂方法是所有这些特殊情况的一般化。

// Collectors.reducing() 是以上情况的一般化
// 菜单中总热量
int totalCalories2 = getMenu().stream()
    .collect(reducing(0,        		// 第一个参数:初始值
					Dish::getCalories, // 第二个参数:转换函数,要被操作的值
					(i, j) -> i + j)); // 第三个参数:累积函数,求和代码
System.out.println(totalCalories2); // 3850

// 菜单中热量最高的菜
Optional<Dish> mostCaloriesDish = getMenu().stream()
    .collect(reducing((d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2));
System.out.println(mostCalaorieDish.orElse(null)); // pork

// collect与reduce
int totalCalories3 = getMenu().stream()
    .map(Dish::getCalories)
    .reduce(Integer::sum)
    .get();
System.out.println(totalCalories3);

分组和分区

按类型对菜肴进行分组

// 按类型分组
Map<Dish.Type, List<Dish>> typeMap = getMenu().stream()
    .collect(groupingBy(Dish::getType));
System.out.println(typeMap);
// {OTHER=[rice, season, pizza], FISH=[prawns, salmon], MEAT=[pork, chicken, french fries]}

// 按热量分组
Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = getMenu().stream()
    .collect(groupingBy(Dish::getCaloricLevel));
System.out.println(dishesByCaloricLevel);
// {DIET=[french fries, season, prawns], FAT=[pork], NORMAL=[chicken, rice, pizza, salmon]}

多级分组

先按类型分,再按热量分

// 先按类型分,再按热量分
Map<Dish.Type, Map<CaloricLevel, List<Dish>>> dishesByTypeCaloriclevel = 
    getMenu().stream()
    	.collect(groupingBy(Dish::getType, groupingBy(Dish::getCaloricLevel)));
System.out.println(dishesByTypeCaloriclevel);
// {OTHER={DIET=[season], NORMAL=[rice, pizza]},
// FISH={DIET=[prawns], NORMAL=[salmon]},
// MEAT={DIET=[french fries], FAT=[pork], NORMAL=[chicken]}}

按子组收集数据

按子组收集数据

// 每种类型的菜有多少个
Map<Dish.Type, Long> typesCount = getMenu().stream()
    .collect(groupingBy(Dish::getType, counting()));
System.out.println(typesCount);
// {OTHER=3, FISH=2, MEAT=3}
// 注意:groupingBy(f)  等价于 groupingBy(f, toList())

把收集器的结果转换为另一种类型

// 每种类型的中最高热量的那个菜
Map<Dish.Type, Optional<Dish>> mostCaloricByType = getMenu().stream()
    .collect(groupingBy(Dish::getType, maxBy(comparingInt(Dish::getCalories))));
System.out.println(mostCaloricByType);
// {OTHER=Optional[pizza], FISH=Optional[salmon], MEAT=Optional[pork]}

// 把收集器的结果转换为另一种类型
// 每种类型的中最高热量的那个菜
Map<Dish.Type, Dish> mostCaloricByType2 = getMenu().stream()
    .collect(groupingBy(Dish::getType, // 分类函数
                        collectingAndThen( // 这是一个收集器
                            maxBy(comparingInt(Dish::getCalories)), // 要转换的收集器
                            Optional::get))); // 转换函数

与groupingBy联合使用的其他收集器的例子

// 与groupingBy联合使用的其他收集器的例子
// 每种类型的总热量
Map<Dish.Type, Integer> totalCaloriesByType = getMenu().stream()
    .collect(groupingBy(Dish::getType,
                        summingInt(Dish::getCalories)));
System.out.println(totalCaloriesByType);

// 每种类型有哪些热量类型
// 使用toSet()
Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType = getMenu().stream()
    .collect(groupingBy(Dish::getType,
                        mapping( 
// 在累加前对每个输入元素应用一个映射函数,这样就可以让接受特定类型元素的收集器适用不同类型的对象
                            Dish::getCaloricLevel, // 对流中的元素做变换
                            toSet()))); // 将变换的结果对象收集起来
System.out.println(caloricLevelsByType);
// {FISH=[NORMAL, DIET], MEAT=[FAT, NORMAL, DIET], OTHER=[NORMAL, DIET]}

// 使用toCollection(HashSet::new)
Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType2 = getMenu().stream()
	.collect(groupingBy(Dish::getType, 
                        mapping(Dish::getCaloricLevel, 
                                toCollection(HashSet::new))));
System.out.println(caloricLevelsByType2);
// {FISH=[NORMAL, DIET], MEAT=[FAT, NORMAL, DIET], OTHER=[NORMAL, DIET]}

特殊情况:分区

分区是分组的特殊情况:由一个谓词(返回一个布尔值的函数)作为分类函数,它称为分区函数。

// 区分素食与非素食
Map<Boolean, List<Dish>> partitionedMenu = getMenu().stream()
    .collect(partitioningBy(Dish::isVegetarian));
System.out.println(partitionedMenu);
// {false=[pork, chicken, french fries, prawns, salmon], true=[rice, season, pizza]}

// 区分素食与非素食,再按类型分类
Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType = getMenu().stream()
    .collect(partitioningBy(Dish::isVegetarian, // 分区函数
                            groupingBy(Dish::getType))); // 收集器

// 素食与非素食中热量最高的菜
Map<Boolean, Dish> mostCaloricPartitionedByVegetarian = getMenu().stream()
    .collect(partitioningBy(Dish::isVegetarian,
                            collectingAndThen(
                                maxBy(comparing(Dish::getCalories)),
                                Optional::get)));
System.out.println(mostCaloricPartitionedByVegetarian);
// {false=pork, true=pizza}

将数字按质数和非质数分区

判断质数

// 质数
public boolean isPrime(int candidate) {
    return IntStream.range(2, candidate)
        .noneMatch(i -> candidate % i == 0);
}

// 优化,仅测试小于等于待测试数平方根的因子(限制除数不超过被测试数的平方根)
public boolean isPrime2(int candidate) {
    int candidateRoot = (int) Math.sqrt((double) candidate);
    return IntStream.rangeClosed(2, candidateRoot)
        .noneMatch(i -> candidate % i == 0);
}

将数字按质数和非质数分区

// 将数字按质数和非质数分区
public Map<Boolean, List<Integer>> partitionPrimes(int n) {
    return IntStream.rangeClosed(2, n).boxed()
        .collect(partitioningBy(candidate -> isPrime2(candidate)));
}

自定义收集器

将Stream里的元素收集到List

/**
 * 将Stream<T>中的所有元素收集到一个List<T>里
 * Author:   admin
 * Date:     2018/8/15 15:03
 */
public class ToListCollector<T> implements Collector<T, List<T>, List<T>> {
    // T是流中要收集的项目的泛型
    // A是累加器的类型,累加器是在收集过程中用于累积部分结果的对象。
    // R是收集操作得到的对象(通常但并不一定是集合)的类型。

    // 建立新的结果容器
    @Override
    public Supplier<List<T>> supplier() {
        // 必须返回一个结果为空的Supplier,也就是一个元参函数
        // 在调用它时它会创建一个空的累加器实例,供数据收集过程使用
        // return () -> new ArrayList<T>();
        return ArrayList::new; // 修建集合操作的起始点
    }

    // 将元素添加到结果容器
    @Override
    public BiConsumer<List<T>, T> accumulator() {
        // 返回执行归约操作的函数
        // return (list, item) -> list.add(item);
        return List::add; // 累积遍历过的项目,原位修改累加器
    }

    // 对结果容器应用最终转换
    @Override
    public Function<List<T>, List<T>> finisher() {
        return Function.identity(); // 恒等函数
    }

    // 合并两个结果容器
    @Override
    public BinaryOperator<List<T>> combiner() {
        return (list1, list2) -> { // 合并两个累加器
            list1.addAll(list2);
            return list1;
        };
    }

    // 返回一个不可变的Characteristics集合
    @Override
    public Set<Characteristics> characteristics() {
        // IDENTITY_FINISH:将累加器A不加检查地转换为结果R是安全的
        // CONCURRENT:accumulator函数可以从多个线程同时调用,且该收集器可以并行归约流
        return Collections.unmodifiableSet( // 为收集器添加标志
                EnumSet.of(Characteristics.IDENTITY_FINISH, 
                        Characteristics.CONCURRENT)); 
    }
}

使用

Stream<Dish> menuStream = FakeDb.getMenu().stream();

// 使用已有的收集器
List<Dish> dishes2 = menuStream.collect(Collectors.toList());

// 使用自定义的收集器
List<Dish> dishes = menuStream.collect(new ToListCollector<Dish>());

// 自定义收集而不去实现Collector
List<Dish> dishes3 = menuStream.collect(
    ArrayList::new, /// 供应源
    List::add, // 累加器
    List::addAll // 组合器
);

将数字按质数和非质数分区

/**
 * 将前n个自然数按质数和非质数分区
 * Author:   admin
 * Date:     2018/8/15 15:28
 */
public class PrimeNumbersCollector implements Collector<Integer,
        Map<Boolean, List<Integer>>,
        Map<Boolean, List<Integer>>> {

    @Override
    public Supplier<Map<Boolean, List<Integer>>> supplier() {
        // 从一个有两个空List的Map开始收集过程
        return () -> new HashMap<Boolean, List<Integer>>() {{
           put(true, new ArrayList<Integer>());
           put(false, new ArrayList<Integer>());
        }};
    }

    @Override
    public BiConsumer<Map<Boolean, List<Integer>>, Integer> accumulator() {
        // 将已经找到的质数列表传递给isPrime方法
        return (Map<Boolean, List<Integer>> acc, Integer candidate) -> {
            // 根据isPrime方法返回值,从Map中取质数或非质数列表,把当前的被测数据加进去
            acc.get(isPrime(acc.get(true), candidate)).add(candidate);
        };
    }

    @Override
    public BinaryOperator<Map<Boolean, List<Integer>>> combiner() {
        // 将第2个Map合并到第1个
        return (Map<Boolean, List<Integer>> map1, Map<Boolean, List<Integer>> map2) -> {
            map1.get(true).addAll(map2.get(true));
            map1.get(false).addAll(map2.get(false));
            return map1;
        };
    }

    @Override
    public Function<Map<Boolean, List<Integer>>, Map<Boolean, List<Integer>>> finisher() {
        return Function.identity();
    }

    @Override
    public Set<Characteristics> characteristics() {
        // 质数是按顺序发现的
        return Collections.unmodifiableSet(EnumSet.of(Characteristics.IDENTITY_FINISH));
    }

    // 再优化,仅仅用被测试数之前的质数来测试
    public static boolean isPrime(List<Integer> primes, int candidate) {
        // return primes.stream().noneMatch(i -> candidate % i == 0);
        int candidateRoot = (int) Math.sqrt((double) candidate);
        return takeWhile(primes, i -> i <= candidateRoot)
                .stream()
                .noneMatch(p -> candidate %p == 0);
    }

    public static <A> List<A> takeWhile(List<A> list, Predicate<A> p) {
        int i = 0;
        for (A item : list) {
            if (!p.test(item)) { // 检查列表中的当前项目是否满足谓词
                return list.subList(0, i); // 如果不满足,返回之前的列表
            }
            i++;
        }
        return list; // 都满足,返回全部
    }
}

使用

// 使用自定义的素数收集器 实现 将数字按质数和非质数分区
public Map<Boolean, List<Integer>> partitionPrimesWithCustomCollector(int n) {
    return IntStream.rangeClosed(2, n).boxed()
        .collect(new PrimeNumbersCollector());
}

比较收集器的性能

@Test
public void test08() {
    long fastest = Long.MAX_VALUE;
    for (int i=0; i<10; i++) {
        long start = System.nanoTime();
        partitionPrimes(1_000_000);
        long duration = (System.nanoTime() - start) / 1_000_000;
        if (duration < fastest) fastest = duration;
    }
    System.out.println("Fastest execution done in " + fastest + " msecs");
    // Fastest execution done in 371 msecs
}

@Test
public void test09() {
    long fastest = Long.MAX_VALUE;
    for (int i=0; i<10; i++) {
        long start = System.nanoTime();
        partitionPrimesWithCustomCollector(1_000_000);
        long duration = (System.nanoTime() - start) / 1_000_000;
        if (duration < fastest) fastest = duration;
    }
    System.out.println("Fastest execution done in " + fastest + " msecs");
    // Fastest execution done in 294 msecs
}

环境:

  • Intel i7-4790 3.60GHz
  • Windows 10
  • jdk 1.8

性能提升(371 - 294) / 371 = 20.75%

总结

收集器的两个功能

  • 归约,特殊情况是汇总,将流元素归约和汇总为一个值
  • 分组,特殊情况是分区

代码

https://gitee.com/yysue/tutorials-java/tree/master/java-8

© 著作权归作者所有

yysue
粉丝 28
博文 272
码字总数 157094
作品 0
济南
程序员
私信 提问
死磕Java 8特性系列---流的深入

本次,读了两本书,一本是《Beginning Java 8 Language Features》,一本是《Java 8 实战》,有感。感觉平时我们都是使用了个Java8相关特性的皮毛。加上以前面试被人问:你知道一个列表我想同...

心中的理想乡
2018/09/19
0
0
Java 8 Stream的性能到底如何?

已经对Stream API的用法鼓吹够多了,用起简洁直观,但性能到底怎么样呢?会不会有很高的性能损失?本节我们对Stream API的性能一探究竟。 为保证测试结果真实可信,我们将JVM运行在模式下,测...

HollisChuang's Blog
03/16
0
0
学习Hadoop资料分享

最近一直在学习Hadoop,没办法,工作需要,最近在网上收集资料时,看到了一个课程,叫Cloudera Hadoop 4系列实战课程(电商业日志流量分析项目),把课程内容的大概给大家看一下,有40课时,看...

adiykk
2013/06/19
929
5
fbf的书单,欢迎分享,欢迎更新

本人看过的以下书值得推荐的,列出来的就是值得推荐的 这个颜色是一般推荐 这个颜色是强烈推荐 这个颜色是神作,收藏吧 物联网:生产力的变革 李虹著 开拓视野,一般 源码中国:全球IT外包新原...

fbf
2015/03/16
0
0
快过年了,我给小明制定了一份价值60万的Java学习计划

1. 有些人觉得,学习计划有什么好制定的——今天是一天,明天是一天,后天还是一天,一天一天的就这样过好了。 但我不这么觉得。 2. 高尔基曾说过:“书籍是人类进步的阶梯。”那,要想在201...

Java邵先生
01/22
0
0

没有更多内容

加载失败,请刷新页面

加载更多

springmvc的return “success”源码解读

qqqq

architect刘源源
今天
4
0
Java程序员五面阿里分享 逆袭成功 太不容易了!

前言 拿到阿里实习offer,经历了5次面试,其中4轮技术面,1轮HR面试。在这里分享一下自己的面试经验和学习心得。希望能够帮助更多的小伙伴。 我本科毕业于中南大学信管专业,真正开始学习Jav...

别打我会飞
昨天
4
0
Android Camera模块解析之视频录制

《Android Camera架构》 《Android Camera进程间通信类总结》 《Android Camera模块解析之拍照》 《Android Camera模块解析之视频录制》 《Android Camera原理之CameraDeviceCallbacks回调模...

天王盖地虎626
昨天
2
0
手把手教你使用issue作为博客评论系统

自从上周在阮一峰的 每周分享第 60 期 看到了可以将 GitHub 的 issue 当作评论系统,插入第三方网页的 JS 库——utterances。我就对此“魂牵梦绕”。个人博客使用的是VuePress。 TLDR (不多废...

jump--jump
昨天
9
0
商业合作模式有几种

公司合作首先要看公司的发展、定位已经公司双方的实力,前期沟通,了解很重要,切不可盲目。一般公司之间合作有以下: 一、六种合作模式 1、资源互换:资源互换是一种双方商定在一段时间内彼此...

吴伟祥
昨天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部