Java8 stream 中利用 groupingBy 进行多字段分组求和案例

Java8的groupingBy实现集合的分组,类似Mysql的group by分组功能,注意得到的是一个map

对集合按照单个属性分组、分组计数、排序

List<String> items =
    Arrays.asList("apple", "apple", "banana",
        "apple", "orange", "banana", "papaya");

// 分组
Map<String, List<String>> result1 = items.stream().collect(
    Collectors.groupingBy(
        Function.identity()
    )
);
//{papaya=[papaya], orange=[orange], banana=[banana, banana], apple=[apple, apple, apple]}
System.out.println(result1);

// 分组计数
Map<String, Long> result2 = items.stream().collect(
    Collectors.groupingBy(
        Function.identity(), Collectors.counting()
    )
);
// {papaya=1, orange=1, banana=2, apple=3}
System.out.println(result2);
Map<String, Long> finalMap = new LinkedHashMap<>();

//分组, 计数和排序
result2.entrySet().stream()
    .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
    .forEachOrdered(e -> finalMap.put(e.getKey(), e.getValue()));
// {apple=3, banana=2, papaya=1, orange=1}
System.out.println(finalMap);

集合按照多个属性分组

1.多个属性拼接出一个组合属性

public static void main(String[] args) {
  User user1 = new User("zhangsan", "beijing", 10);
  User user2 = new User("zhangsan", "beijing", 20);
  User user3 = new User("lisi", "shanghai", 30);
  List<User> list = new ArrayList<User>();
  list.add(user1);
  list.add(user2);
  list.add(user3);
  Map<String, List<User>> collect = list.stream().collect(Collectors.groupingBy(e -> fetchGroupKey(e)));
  //{zhangsan#beijing=[User{age=10, name='zhangsan', address='beijing'}, User{age=20, name='zhangsan', address='beijing'}],
  // lisi#shanghai=[User{age=30, name='lisi', address='shanghai'}]}
  System.out.println(collect);
} 

private static String fetchGroupKey(User user){
  return user.getName() +"#"+ user.getAddress();
}

2.嵌套调用groupBy

User user1 = new User("zhangsan", "beijing", 10);
User user2 = new User("zhangsan", "beijing", 20);
User user3 = new User("lisi", "shanghai", 30);
List<User> list = new ArrayList<User>();
list.add(user1);
list.add(user2);
list.add(user3);
Map<String, Map<String, List<User>>> collect
    = list.stream().collect(
        Collectors.groupingBy(
            User::getAddress, Collectors.groupingBy(User::getName)
        )
);
System.out.println(collect);

3. 使用Arrays.asList

我有一个与Web访问记录相关的域对象列表。这些域对象可以扩展到数千个。

我没有资源或需求将它们以原始格式存储在数据库中,因此我希望预先计算聚合并将聚合的数据放在数据库中。

我需要聚合在5分钟窗口中传输的总字节数,如下面的sql查询

select
 round(request_timestamp, '5') as window, --round timestamp to the nearest 5 minute
 cdn,
 isp,
 http_result_code,
 transaction_time,
 sum(bytes_transferred)
from web_records
group by
  round(request_timestamp, '5'),
  cdn,
  isp,
  http_result_code,
  transaction_time

在java 8中,我当前的第一次尝试是这样的,我知道这个解决方案类似于Group by multiple field names in java 8

Map<Date, Map<String, Map<String, Map<String, Map<String, Integer>>>>>>> aggregatedData =
webRecords
  .stream()
  .collect(Collectors.groupingBy(WebRecord::getFiveMinuteWindow,
        Collectors.groupingBy(WebRecord::getCdn,
         Collectors.groupingBy(WebRecord::getIsp,
          Collectors.groupingBy(WebRecord::getResultCode,
            Collectors.groupingBy(WebRecord::getTxnTime,
             Collectors.reducing(0,
                       WebRecord::getReqBytes(),
                       Integer::sum)))))));

这是可行的,但它是丑陋的,所有这些嵌套的地图是一个噩梦!要将地图“展平”或“展开”成行,我必须这样做

for (Date window : aggregatedData.keySet()) {
 for (String cdn : aggregatedData.get(window).keySet()) {
  for (String isp : aggregatedData.get(window).get(cdn).keySet()) {
   for (String resultCode : aggregatedData.get(window).get(cdn).get(isp).keySet()) {
    for (String txnTime : aggregatedData.get(window).get(cdn).get(isp).get(resultCode).keySet()) {

      Integer bytesTransferred = aggregatedData.get(window).get(cdn).get(distId).get(isp).get(resultCode).get(txnTime);
      AggregatedRow row = new AggregatedRow(window, cdn, distId...

如你所见,这是相当混乱和难以维持。

有谁知道更好的方法吗?任何帮助都将不胜感激。

我想知道是否有更好的方法来展开嵌套的映射,或者是否有一个库允许您对集合进行分组。

最佳答案

您应该为地图创建自定义密钥。最简单的方法是使用Arrays.asList:

Function<WebRecord, List<Object>> keyExtractor = wr ->
  Arrays.<Object>asList(wr.getFiveMinuteWindow(), wr.getCdn(), wr.getIsp(),
       wr.getResultCode(), wr.getTxnTime());

Map<List<Object>, Integer> aggregatedData = webRecords.stream().collect(
   Collectors.groupingBy(keyExtractor, Collectors.summingInt(WebRecord::getReqBytes)));

在这种情况下,键是按固定顺序列出的5个元素。不是很面向对象,但很简单。或者,您可以定义自己的表示自定义键的类型,并创建适当的hashCode/equals实现。

补充知识:java8 新特性 Stream流 分组 排序 过滤 多条件去重 (最小、最大、平均、求和)

什么是 Stream?

Stream 是用函数式编程方式在集合类上进行复杂操作的工具,其集成了Java 8中的众多新特性之一的聚合操作,开发者可以更容易地使用Lambda表达式,并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。话不多说,直接上代码。

List<User> list = new ArrayList<User>();
list = Arrays.asList(
    new User("小强", 11, "男"),
    new User("小玲", 15, "女"),
    new User("小虎", 23, "男"),
    new User("小雨", 26, "女"),
    new User("小飞", 19, "男"),
    new User("小玲", 15, "女")
);
//分组
Map<String, List<User>> listMap = list.stream().collect(Collectors.groupingBy(User::getSex));
for(String key:listMap.keySet()){
  System.out.print(key+"组:");
  listMap.get(key).forEach(user -> System.out.print(user.getName()));
  System.out.println();
}
//排序
list.stream().sorted(Comparator.comparing(user-> user.getAge()))
    .forEach(user -> System.out.println(user.getName()));
//过滤
list.stream().filter(user -> user.getSex().equals("男")).collect(Collectors.toList())
    .forEach(user -> System.out.println(user.getName()));
//多条件去重
list.stream().collect(Collectors.collectingAndThen(
    Collectors.toCollection(() -> new TreeSet<>(
        Comparator.comparing(user -> user.getAge() + ";" + user.getName()))), ArrayList::new))
    .forEach(user -> System.out.println(user.getName()));
//最小值
Integer min = list.stream().mapToInt(User::getAge).min().getAsInt();
//最大值
Integer max = list.stream().mapToInt(User::getAge).max().getAsInt();
//平均值
Double average = list.stream().mapToInt(User::getAge).average().getAsDouble();
//和
Integer sum = list.stream().mapToInt(User::getAge).sum();
System.out.println("最小值:"+min+", 最大值"+max+", 平均值:"+average+", 和:"+sum);
//分组求和
Map<String, IntSummaryStatistics> collect = list.stream().collect(Collectors.groupingBy(User::getSex, Collectors.summarizingInt(User::getAge)));
IntSummaryStatistics statistics1 = collect.get("男");
IntSummaryStatistics statistics2 = collect.get("女");
System.out.println(statistics1.getSum());
System.out.println(statistics1.getAverage());
System.out.println(statistics1.getMax());
System.out.println(statistics1.getMin());
System.out.println(statistics1.getCount());
System.out.println(statistics2.getSum());
System.out.println(statistics2.getAverage());
System.out.println(statistics2.getMax());
System.out.println(statistics2.getMin());
System.out.println(statistics2.getCount());
//提取list中两个属性值,转为map
Map<String, String> userMap = list.stream().collect(Collectors.toMap(User::getName, User::getSex));
System.out.println(JsonUtil.toJson(userMap))
//取出所有名字
List<String> names = list.stream().map(User::getName).collect(Collectors.toList());
System.out.println(JsonUtil.toJson(names))

以上这篇Java8 stream 中利用 groupingBy 进行多字段分组求和案例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • JAVA8 stream中三个参数的reduce方法对List进行分组统计操作

    背景 平时在编写前端代码时,习惯使用lodash来编写'野生'的JavaScript; lodash提供来一套完整的API对JS对象(Array,Object,Collection等)进行操作,这其中就包括_.groupBy 和 _.reduce,即分组和'聚合'(reduce不知道该怎么翻译合适). 使用这些'野生'的API能够极大的提高我本人编写JS代码的效率.而JAVA8开始支持stream和lambda表达式,这些和lodash的API有很多类似的功能.因此我在熟悉lodash的前提下尝

  • java8新特性 stream流的方式遍历集合和数组操作

    前言: 在没有接触java8的时候,我们遍历一个集合都是用循环的方式,从第一条数据遍历到最后一条数据,现在思考一个问题,为什么要使用循环,因为要进行遍历,但是遍历不是唯一的方式,遍历是指每一个元素逐一进行处理(目的),而并不是从第一个到最后一个顺次处理的循环,前者是目的,后者是方式. 所以为了让遍历的方式更加优雅,出现了流(stream)! 1.流的目的在于强掉做什么 假设一个案例:将集合A根据条件1过滤为子集B,然后根据条件2过滤为子集C 在没有引入流之前我们的做法可能为: public cl

  • JAVA JDK8 List分组的实现和用法

    概述 对List进行分组是日常开发中,经常遇到的,在JDK 8中对List按照某个属性分组的代码,超级简单. package test; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.serializer.SerializerFeature; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util

  • java8 集合 多字段 分组 统计个数代码

    1.user实体 package com.demo.dto; public class User { private Integer id; private String userName; private String password; private Integer age; private long c; public User() { super(); // TODO Auto-generated constructor stub } public User(Integer id, S

  • Java8 stream 中利用 groupingBy 进行多字段分组求和案例

    Java8的groupingBy实现集合的分组,类似Mysql的group by分组功能,注意得到的是一个map 对集合按照单个属性分组.分组计数.排序 List<String> items = Arrays.asList("apple", "apple", "banana", "apple", "orange", "banana", "papaya");

  • java8 stream 由一个list转化成另一个list案例

    我就废话不多说了,大家还是直接看代码吧~ // 利用stream进行类型转化 List<String> stringList = new ArrayList<>(); stringList.add("a11"); stringList.add("b11"); stringList.add("c11"); stringList.add("d11"); stringList.add("e11&qu

  • java8 stream中Collectors.toMap空指针问题及解决

    目录 Collectors.toMap空指针问题 Collectors.toMap的坑 Collectors.toMap空指针问题 在工作中遇到了一个List转Map的时候的一个NullPointException. 情形很简单,问题出在Collectors.toMap,当key值冲突的时候理论上会按照我们的代码来替换value,但是这里有个小坑 list.stream().collect(Collectors.toMap(it -> it.getCategoryId(), it -> it.

  • java8 stream sort自定义复杂排序案例

    java 8 自定义排序 需求 今天在项目中遇到个需求,按照对象中的三个属性进行排序. 具体要求: 前提:对象 Obj [a=a,b=b,c=c] 1. 优先级为a > b > c 2. a属性为中文,固定排序规则为:政府,合作,基金 - - 3. b的为BigDecimal类型,固定的排序规则为:降序排序 4. c为java.util.Date类型,规则为:降序排序 其实看这个需求,第3点和第4点不是什么问题,但是第1点,会考虑下怎么实现好. 直接上方案吧! 方案一 新建一张排序表,至少要有

  • Java8 Stream 流常用方法合集

    目录 一.概述 二.分类 三.具体用法 1. 流的常用创建方法 2. 流的中间操作 3. 流的终止操作 一.概述 Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找.过滤和映射数据等操作.使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询.也可以使用 Stream API 来并行执行操作. 简而言之,Stream API 提供了一种高效且易于使用的处理数据的方式. 特点: 不是数据结构,不会保存数据.

  • Java8中利用stream对map集合进行过滤的方法

    前言 Stream 是用函数式编程方式在集合类上进行复杂操作的工具,其集成了Java 8中的众多新特性之一的聚合操作,开发者可以更容易地使用Lambda表达式,并且更方便地实现对集合的查找.遍历.过滤以及常见计算等. 最近公司在大张旗鼓的进行代码审核,从中也发现自己写代码的不好习惯.一次无意的点到了公司封装的对map集合过滤的方法,发现了stream.于是研究了一下.并对原有的代码再次结合Optional进行重构下 原有方法说明 主要处理过滤条件Map对象,过滤掉了null和空字符串 等操作 这

  • Java8 Stream流多字段求和、汇聚的实例

    目录 Stream流多字段求和.汇聚 实现方法 对象类型数据处理 Map类型数据处理 Stream分组求和使用笔记 分组求和使用 Stream流多字段求和.汇聚 实现方法 利用 Collectors.toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) keyMapper:代表你最终想要获得的Map<Key, Value> 的Key valueMapper:代表你最终想要获得的Map<K

  • java8 利用reduce实现将列表中的多个元素的属性求和并返回操作

    利用java8流的特性,我们可以实现list中多个元素的 属性求和 并返回. 案例: 有一个借款待还信息列表,其中每一个借款合同包括:本金.手续费: 现在欲将 所有的本金求和.所有的手续费求和. 我们可以使用java8中的函数式编程,获取list的流,再利用reduce遍历递减方式将同属性(本金.手续费)求和赋予给一个新的list中同类型的对象实例,即得到我们需要的结果: A a = list.stream() .reduce( (x , y) -> new A( (x.getPrincipal

  • java8 stream的多字段排序实现(踩坑)

    关于java8 的stream排序用法这里不做多说,这里介绍下曾经在多字段排序时遇到过的一个坑. 需求:需要根据id去分组,然后取出每组中行号最大的一个对象值. 想到可以利用stream的多字段排序,先按id去排,再看行号去排,demo代码如下: class Tt{ private int id; private int line; public Tt(int id, int line) { this.id = id; this.line = line; } public int getId()

随机推荐