Java8 使用流对集合进行分组groupingBy操作

已于 2022-06-02 11:08:48 修改
阅读量6.1k 收藏 14
点赞数 3
分类专栏： JAVA8 新特性 文章标签： java 开发语言
于 2019-08-14 20:37:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010979642/article/details/98639064
版权

实体对象

@Data
@AllArgsConstructor
public class Kvs<T> {
    private String key;
    private T value;
}

 

代码实操

public class AnswerApp {

    public static void main(String[] args) {
        List<Kvs<String>> kvsList = Lists.newArrayList(
                new Kvs<>("A0001", "Answer"),new Kvs<>("A0001", "AnswerAIL"),new Kvs<>("A0001", "AI"),
                new Kvs<>("A0002", "Iris"),new Kvs<>("A0002", "IrisA"),new Kvs<>("A0003", "Allen"),
                new Kvs<>("A004", "James"),new Kvs<>("A005", "Kak"),new Kvs<>("A005", "KaKa")
        );

        // 对 key 进行统计个数
        Map<String, Long> map1 = kvsList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.counting()));
        System.out.println("map1=" + JSON.toJSONString(map1));
        System.out.println();

        // 根据 key 对集合进行分组-1
        Map<String, List<Kvs>> map2_1 = kvsList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.toList()));
        System.out.println("map2_1=" + JSON.toJSONString(map2_1));
        System.out.println();

        // 根据 key 对集合进行分组-2
        Map<String, List<Kvs>> map2_2 = kvsList.stream().collect(Collectors.groupingBy(Kvs::getKey));
        System.out.println("map2_2=" + JSON.toJSONString(map2_2));
        System.out.println();

        // 根据 key 对集合进行分组, 并且 value 的集合为指定属性集合而不是对象
        Map<String, List<String>> map3 = kvsList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.mapping(Kvs::getValue, Collectors.toList())));
        System.out.println("map3=" + JSON.toJSONString(map3));
        System.out.println();
        // List<Kvs> -> Map<String, List<Order>>
//        Map<String, List<Order>> map3 = kvsList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.mapping(e -> new Order(e.getNo(), e.getAmt(), Collectors.toList())));

        // 根据 key 进行分组并且将指定属性值进行拼接作为哈希表的 value 值
        Map<String, String> map4 = kvsList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.mapping(Kvs::getValue, Collectors.joining("#"))));
        System.out.println("map4=" + JSON.toJSONString(map4));
        System.out.println();

        // 根据 key 进行分组并根据 指定属性进行比较取最大元素
        Map<String, Optional<Kvs<String>>> map5 = kvsList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.maxBy(Comparator.comparing(Kvs::getValue))));
        System.out.println("map5=" + JSON.toJSONString(map5));
        System.out.println();

        // partitioningBy 会根据 传入的 表达式进行判断, 将集合分为 true 和 false 两个列表
        Map<Boolean, List<Kvs>> map6 = kvsList.stream().collect(Collectors.partitioningBy(kvs -> "A0001".equals(kvs.getKey())));
        System.out.println("map6=" + JSON.toJSONString(map6));
        System.out.println();

        // 遍历结果集
        kvsList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.toList())).forEach((k, v) -> {
            System.out.println(MessageFormat.format("key={0}, value={1}", k, v));
        });


        List<Kvs<Integer>> numList = Lists.newArrayList(
                new Kvs<>("A001", 1),new Kvs<>("A001", 2),new Kvs<>("A001", 3),
                new Kvs<>("A002", 5),new Kvs<>("A002", 3),new Kvs<>("A003", 7)
        );
        System.out.println();

        // 根据 key 进行分组并且根据 指定数据进行统计
        Map<String, Integer> num1 = numList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.summingInt(Kvs::getValue)));
        System.out.println("num1=" + JSON.toJSON(num1));
        System.out.println();

        // summarizingInt 用来同时计算 average、min、max、count、sum
        Map<String, IntSummaryStatistics> num2 = numList.stream().collect(Collectors.groupingBy(Kvs::getKey, Collectors.summarizingInt(Kvs::getValue)));
        System.out.println("num2=" + JSON.toJSON(num2));
        System.out.println();

		// 集合实体转 实体中某一字段集合
		List<String> keys = kvsList.stream().map(Kvs::getKey).collect(Collectors.toList());
    }

}

 

程序输出

map1={"A0001":3,"A0002":2,"A005":2,"A004":1,"A0003":1}

map2_1={"A0001":[{"key":"A0001","value":"Answer"},{"key":"A0001","value":"AnswerAIL"},{"key":"A0001","value":"AI"}],"A0002":[{"key":"A0002","value":"Iris"},{"key":"A0002","value":"IrisA"}],"A005":[{"key":"A005","value":"Kak"},{"key":"A005","value":"KaKa"}],"A004":[{"key":"A004","value":"James"}],"A0003":[{"key":"A0003","value":"Allen"}]}

map2_2={"A0001":[{"key":"A0001","value":"Answer"},{"key":"A0001","value":"AnswerAIL"},{"key":"A0001","value":"AI"}],"A0002":[{"key":"A0002","value":"Iris"},{"key":"A0002","value":"IrisA"}],"A005":[{"key":"A005","value":"Kak"},{"key":"A005","value":"KaKa"}],"A004":[{"key":"A004","value":"James"}],"A0003":[{"key":"A0003","value":"Allen"}]}

map3={"A0001":["Answer","AnswerAIL","AI"],"A0002":["Iris","IrisA"],"A005":["Kak","KaKa"],"A004":["James"],"A0003":["Allen"]}

map4={"A0001":"Answer#AnswerAIL#AI","A0002":"Iris#IrisA","A005":"Kak#KaKa","A004":"James","A0003":"Allen"}

map5={"A0001":{"key":"A0001","value":"AnswerAIL"},"A0002":{"key":"A0002","value":"IrisA"},"A005":{"key":"A005","value":"Kak"},"A004":{"key":"A004","value":"James"},"A0003":{"key":"A0003","value":"Allen"}}

map6={false:[{"key":"A0002","value":"Iris"},{"key":"A0002","value":"IrisA"},{"key":"A0003","value":"Allen"},{"key":"A004","value":"James"},{"key":"A005","value":"Kak"},{"key":"A005","value":"KaKa"}],true:[{"key":"A0001","value":"Answer"},{"key":"A0001","value":"AnswerAIL"},{"key":"A0001","value":"AI"}]}

key=A0001, value=[Kvs(key=A0001, value=Answer), Kvs(key=A0001, value=AnswerAIL), Kvs(key=A0001, value=AI)]
key=A0002, value=[Kvs(key=A0002, value=Iris), Kvs(key=A0002, value=IrisA)]
key=A005, value=[Kvs(key=A005, value=Kak), Kvs(key=A005, value=KaKa)]
key=A004, value=[Kvs(key=A004, value=James)]
key=A0003, value=[Kvs(key=A0003, value=Allen)]

num1={"A003":7,"A001":6,"A002":8}

num2={"A003":{"average":7.0,"min":7,"max":7,"count":1,"sum":7},"A001":{"average":2.0,"min":1,"max":3,"count":3,"sum":6},"A002":{"average":4.0,"min":3,"max":5,"count":2,"sum":8}}

 

扩展-20190809

// List<T> 转 Map<T#Prop, Map<T#Prop2, T#Prop3>>
List<Kvi> params = Lists.newArrayList();

// 加工数据...  params.add(new Kvi());

/*
 * -----------------------------------------------------------------------------------------------------------------------------------------------------
 * 丨        params                   丨                    rleParams
 * -----------------------------------------------------------------------------------------------------------------------------------------------------
 * 丨    1, Name, zhangsan            丨
 * 丨    1, Liandate, 20190809        丨
 * 丨    1, Status, Open              丨    {1: {Name: zhangsan, Liandate: 20190809, Status: Open}, 2: {Name: lisi, Liandate: 20190809, Status: Close}}
 * 丨    2, Name, lisi                丨
 * 丨    2, Liandate, 20190809        丨
 * 丨    2, Status, Close             丨
 * -----------------------------------------------------------------------------------------------------------------------------------------------------
 * */
Map<Integer, Map<String, String>> rleParams = params.stream().collect(Collectors.groupingBy(Kvi::getIndex, Collectors.toMap(Kvi::getKey, Kvi::getValue)));



@Data
public class Kvi {
    private Integer index;
    private String key;
    private String value;
}

 

public class AnswerApp {

    public static void main(String[] args) {
        List<User> users = Lists.newArrayList(
                new User("高三1班", "stu01", "男"),
                new User("高三1班", "stu02", "女"),
                new User("高三2班", "stu11", "男"),
                new User("高三2班", "stu12", "女"),
                new User("高三3班", "stu21", "女"),
                new User("高三3班", "stu22", "男"),
                new User("高三3班", "stu23", "女"));

        Map<String, List<User>> collect = users.stream().collect(groupingBy(User::getClassName));
        System.out.println(JSON.toJSONString(collect));
        System.out.println();

        Map<String, Long> collect1 = users.stream().collect(groupingBy(User::getClassName, Collectors.counting()));
        System.out.println(JSON.toJSONString(collect1));
        System.out.println();

        Map<String, Map<String, User>> collect2 = users.stream().collect(groupingBy(User::getClassName, Collectors.toMap(User::getStudentName, o -> o)));
        System.out.println(JSON.toJSONString(collect2));
        System.out.println();
    }

    @Data
    @AllArgsConstructor
    private static class User {
        private String className;
        private String studentName;
        private String sex;
    }
}

程序运行结果

{"高三3班":[{"className":"高三3班","sex":"女","studentName":"stu21"},{"className":"高三3班","sex":"男","studentName":"stu22"},{"className":"高三3班","sex":"女","studentName":"stu23"}],"高三2班":[{"className":"高三2班","sex":"男","studentName":"stu11"},{"className":"高三2班","sex":"女","studentName":"stu12"}],"高三1班":[{"className":"高三1班","sex":"男","studentName":"stu01"},{"className":"高三1班","sex":"女","studentName":"stu02"}]}

{"高三3班":3,"高三2班":2,"高三1班":2}

{"高三3班":{"stu21":{"className":"高三3班","sex":"女","studentName":"stu21"},"stu23":{"className":"高三3班","sex":"女","studentName":"stu23"},"stu22":{"className":"高三3班","sex":"男","studentName":"stu22"}},"高三2班":{"stu12":{"className":"高三2班","sex":"女","studentName":"stu12"},"stu11":{"className":"高三2班","sex":"男","studentName":"stu11"}},"高三1班":{"stu02":{"className":"高三1班","sex":"女","studentName":"stu02"},"stu01":{"className":"高三1班","sex":"男","studentName":"stu01"}}}

 

扩展20220602

	public static void main(String[] args) {
        List<UserInfo> users = Lists.newArrayList();
        users.add(new UserInfo(1L, "chinese", BigDecimal.valueOf(150)));
        users.add(new UserInfo(2L, "chinese", BigDecimal.valueOf(100)));
        users.add(new UserInfo(3L, "chinese", BigDecimal.valueOf(120)));
        users.add(new UserInfo(4L, "math", BigDecimal.valueOf(130)));
        users.add(new UserInfo(5L, "math", BigDecimal.valueOf(125)));
        users.add(new UserInfo(6L, "math", BigDecimal.valueOf(145)));


        // 按学科名称分组后，再取分组中分数最高的一个
        Map<String, UserInfo> collect = users.stream().collect(
                Collectors.groupingBy(e ->
                                e.getSubject(),
                        Collectors.collectingAndThen(
                                Collectors.maxBy(Comparator.comparing(UserInfo::getScore)),
                                e -> e.get()
                        )
                )
        );

        System.out.println(collect);
    }

{chinese=UserInfo(id=1, subject=chinese, score=150), math=UserInfo(id=6, subject=math, score=145)}
Jaemon
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
使用 Java 流进行分组和聚合
CCqwas的博客
02-28 1075
了解使用 Java Streams 解决问题的直接途径，Java Streams 是一个允许我们快速有效地处理大量数据的框架。 当我们对列表中的元素进行分组时，我们可以随后聚合分组元素的字段以执行有意义的操作，帮助我们分析数据。一些示例是加法、平均值或最大值/最小值。这些单个字段的聚合可以使用 Java Streams 和 Collectors 轻松完成。该文档提供了如何进行这些类型计算的简单示例。 但是，还有更复杂的聚合，例如加权平均值、几何平均值。此外，可能需要同时聚合多个字段。在本文中，我
java 8 集合分组_Java 8：按集合分组
最佳 Java 编程
06-12 6153
java 8 集合分组 在继续阅读Venkat Subramaniam的“ Java函数式编程 ”时，我到达了介绍Stream＃collect函数的那部分。 我们想收集一个人，按年龄分组并返回一张方便的地图（年龄->人的名字）。 要刷新，这是Person类的样子： static class Person { private String name; privat...
流的多层次分组
最佳 Java 编程
06-01 449
1.简介 使用Java 8流，可以很容易地根据不同的标准对对象集合进行分组。 在这篇文章中，我们将看到如何从简单的单级分组到更复杂的，涉及多个级分组的分组。 我们将使用两个类来表示我们要分组的对象：人和宠物。 人类 public class Person { private final String name; private final String countr...
Java零基础-集合：Java 8新增的集合操作
最新发布
喵手的博客
07-05 394
Java是一种广泛应用于软件开发领域的高级编程语言，具有可移植性和跨平台的特性。在Java的发展过程中，不断有新的功能和语法特性引入，以便开发者能够更加方便和高效地编写代码。其中，在Java 8中引入了许多强大的集合操作，本文将重点介绍这些新增的集合操作。Java 8新增的集合操作为开发人员提供了一种更简单，更灵活的方式来处理集合。这些新的操作包括流(Stream)、过滤器(Filter)、映射(Map)和归约(Reduce)，它们可以大大简化编写和理解集合处理代码的过程。
java8集合分组
HXiao0805的博客
10-28 3756
使用groupingBy函数对集合进行分组统计。 使用情景：对学生信息进行统计，统计每个班级男生人数、女生人数。 分组思想如下： 学生类 public class Student { private String classId; private String name; private String sex; private Integer age; private Integer height; public String getClass.
Java 8：按集合分组
最佳 Java 编程
05-20 1139
在继续阅读Venkat Subramaniam的“ Java函数式编程 ”时，我到达了介绍Stream＃collect函数的那部分。 我们想收集一个人，按年龄分组，并返回一张方便的（年龄->人名）地图。 要刷新，这是Person类的样子： static class Person { private String name; private int age; ...
groupby java_Java8的groupBy实现集合的分组
weixin_36117191的博客
02-20 1042
场景：Java8的groupBy实现集合的分组，类似Mysql的group by分组功能，注意得到的是一个map1.对集合按照单个属性分组e.g. 按照skuId分组Map> detailsMap01 = dtos1.stream().collect(Collectors.groupingBy(EntryDeliveryDetailywk::getskuId));122对集合按照多个属性分组...
Java 8 – 分组GroupBy
热门推荐
Shangri-La
10-01 3万+
1. 分组, 计数和排序 public static void main(String[] args) { //3 apple, 2 banana, others 1 List items = Arrays.asList("apple", "apple", "banana",
Java8 stream 中利用 groupingBy 进行多字段分组求和案例
09-07
其中，`groupingBy`方法就是其中一个非常实用的功能，它允许我们根据指定的条件对集合中的元素进行分组。在这个案例中，我们将探讨如何使用`groupingBy`进行多字段分组以及如何实现分组求和。 首先，`groupingBy`的...
java1.8 中 stream 的 groupingBy 最大值、最小值分组
05-20
主要是介绍在 JDK8中使用 stream 流的 groupingBy 方法源进行最大值分组、最小值分组、平均值分组、统计分组
java8 集合 多字段 分组 统计个数代码
09-07
这里我们将深入探讨如何使用Java 8的Stream API对集合进行多字段分组和统计个数。 首先，我们有一个`User`实体类，包含了`id`, `userName`, `password`, `age`等字段。这个例子中，我们想要根据`userName`和`age`两...
JAVA JDK8 List分组获取第一个元素的方法
08-26
我们使用Collectors.groupingBy方法对List对象进行分组，按照Coupon的couponId字段进行分组。然后，我们使用Collectors.collectingAndThen方法对组内的元素进行处理，获取每个组的第一个元素。 在输出结果中，我们...
java分组求和_Java8stream中利用groupingBy进行多字段分组求和
weixin_32267059的博客
02-27 4388
对集合按照单个属性分组、分组计数、排序List items =Arrays.asList("apple", "apple", "banana","apple", "orange", "banana","papaya");// 分组Map> result1 = items.stream().collect(Collectors.groupingBy(Function.identity()));...
使用流分组
qq_45396088的博客
05-20 77
将SocinsReviewContentView按照reviewId分组 Map<Long,List>collect=reviewContentViews.stream().collect(Collectors.groupingBy(SocinsReviewContentView::getReviewId));
Java8 List<对象> 转 Set、Map（高级）、排序、分组、统计
weixin_33704234的博客
07-25 566
实体类 public class Student { private int id; private String name; private String score; private int classNo; public Student(int id, String name, String score, int classNo...
利用java8新特性对集合进行分组，只需要一行优雅的代码
li_tianyang的博客
11-22 179
最核心的代码为这一行，调用Collectors里面的groupingBy方法，对list集合中的每一个元素的itemId进行过滤分组，分组后的数据以key:value的形式存储在ConcurrentHashMap中，key为itemId，value为具有相同itemId的元素集合。stream是面向方法的一类jdk提供的api，让我们再平时开发的时候减少很多代码量，而且还丰富多彩。
Java8 Stream 按单一属性和多个属性实现集合分组
长安明月的博客
08-10 1万+
  项目中已经通过处理逻辑获得了一个列表，后续需要根据列表的一个属性或多个属性对其分组，可以采用 Java8 的 Stream 实现。   举例说明如下，创建一个 Java Class，名为 Student，其有四个属性，分别是：学号（stuNo）、姓名（stuNm）、年龄（age）、性别（sex）。现有一个学生列表，分别根据年龄（单一属性）、年龄和性别（多属性）进行分组。   Student 类定义如下： package com.test.model; import lombok.Getter; @G
java8 GroupingBy 用法大全
一路向前
07-29 1430
常见使用聚合再进行map处理，用于匹配数据。了解Collectors.collectingAndThen的用法，聚合后再进行操作。写不来，就分两步写，先完成，再优化
Java8 groupingBy 分组，真的很好用
清晨qc的博客
12-13 815
上面是笔者经常使用的几种 stream 流的 groupingBy 分组操作，后续如有扩展，再进行补充。
使用java8对一个map集合进行分组
05-26
在Java 8中，可以使用`Collectors.groupingBy()`方法对集合进行分组。以下是一个示例代码： 假设我们有一个Person类，其属性包括姓名和年龄： ``` public class Person { private String name; private int age;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jaemon

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值