Java stream多字段分组(groupingBy)

这篇具有很好参考价值的文章主要介绍了Java stream多字段分组(groupingBy)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

近期的项目里,遇到一个需求:对于含有多个元素的List<Person>,按照其中的某几个属性进行分组,比如Persion::getAgePersion::getTypePersion::getGender等字段。下面就让我们讨论一下如何比较优雅的按多字段进行分组groupingBy。

利用Stream进行分组

Stream是Java8的一个新特性,主要用户集合数据的处理,如排序、过滤、去重等等功能,这里我们不展开讲解。本文主要讲解的是利用Stream.collect()来对List进行分组。
Person类Person.java:

public class Person {

    /**
     * id
     */
    private Integer id;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 类型
     */
    private String type;

    /**
     * 姓名
     */
    private String name;

    /**
     * 性别
     */
    private String gender;

    public Integer getId() {
        return id;
    }

    public Person setId(Integer id) {
        this.id = id;
        return this;
    }

    public Integer getAge() {
        return age;
    }

    public Person setAge(Integer age) {
        this.age = age;
        return this;
    }

    public String getType() {
        return type;
    }

    public Person setType(String type) {
        this.type = type;
        return this;
    }

    public String getName() {
        return name;
    }

    public Person setName(String name) {
        this.name = name;
        return this;
    }

    public String getGender() {
        return gender;
    }

    public Person setGender(String gender) {
        this.gender = gender;
        return this;
    }
}

1. 利用单个字段进行分组

如上面的Person类,如果对于其中的某一个字段进行分组(如gender),则比较简单,我们可以利用Stream.collect()Collectors.groupingBy结合,即可进行分组groupingBy,代码如下:

public class TestGroupingBy {

    public static void main(String[] args) {

        List<Person> personList = Arrays.asList(
                new Person().setId(1).setAge(18).setType("student").setName("user - 1").setGender("male"),
                new Person().setId(2).setAge(20).setType("student").setName("user - 2").setGender("male"),
                new Person().setId(3).setAge(18).setType("student").setName("user - 3").setGender("male"),
                new Person().setId(4).setAge(18).setType("student").setName("user - 4").setGender("male"),
                new Person().setId(5).setAge(35).setType("teacher").setName("user - 5").setGender("male"),
                new Person().setId(6).setAge(35).setType("teacher").setName("user - 6").setGender("male"),
                new Person().setId(7).setAge(20).setType("student").setName("user - 7").setGender("male"),
                new Person().setId(8).setAge(20).setType("student").setName("user - 8").setGender("female"),
                new Person().setId(9).setAge(20).setType("student").setName("user - 9").setGender("female"),
                new Person().setId(10).setAge(20).setType("student").setName("user - 10").setGender("female")
        );

        Map<String, List<Person>> groupingMap = personList.stream().collect(Collectors.groupingBy(Person::getGender));
}

其中的groupingMap ,类型为Map<String, List<Person>>,第一个泛型为String即分组字段(本例中为gender字段)的类型,第二个泛型为List<Person>及分组结果的类型。
我们在Debug模式下运行代码,可以看到groupingMap 数据如下:
stream多字段分组,java,后端,stream
可以看到personList数据按照gender属性被分成了两组。

2. 利用多个字段进行分组

上面的例子是按单个字段分组,如果需要按照多个字段,如gender、age、type三个字段进行分组,同样也可以可以利用Stream.collect()Collectors.groupingBy结合的方式进行分组,不过该方式中调用Collectors.groupingBy时需要多次嵌套调用,测试代码如下:

public class TestGroupingBy {

    public static void main(String[] args) {

        List<Person> personList = Arrays.asList(
                new Person().setId(1).setAge(18).setType("student").setName("user - 1").setGender("male"),
                new Person().setId(2).setAge(20).setType("student").setName("user - 2").setGender("male"),
                new Person().setId(3).setAge(18).setType("student").setName("user - 3").setGender("male"),
                new Person().setId(4).setAge(18).setType("student").setName("user - 4").setGender("male"),
                new Person().setId(5).setAge(35).setType("teacher").setName("user - 5").setGender("male"),
                new Person().setId(6).setAge(35).setType("teacher").setName("user - 6").setGender("male"),
                new Person().setId(7).setAge(20).setType("student").setName("user - 7").setGender("male"),
                new Person().setId(8).setAge(20).setType("student").setName("user - 8").setGender("female"),
                new Person().setId(9).setAge(20).setType("student").setName("user - 9").setGender("female"),
                new Person().setId(10).setAge(20).setType("student").setName("user - 10").setGender("female")
        );

        // 多字段嵌套分组
        Map<String, Map<Integer, Map<String, List<Person>>>> groupingMap = personList.stream().collect(
                Collectors.groupingBy(Person::getGender, 
                        Collectors.groupingBy(Person::getAge, 
                                Collectors.groupingBy(Person::getType)
                        )
                )
        );

    }
}

其中groupingMap类型为Map<String, Map<Integer, Map<String, List<Person>>>>,是一个嵌套了三层的Map,对应的泛型String/Integer/String分别为对应分组字段的类型,最后一层Map的value类型为List<Person>为实际分组后的数据集合类型,为方便查看数据,特意按Json格式贴出数据如下:

{
  "female": {
    "20": {
      "student": [
        {
          "id": 8,
          "age": 20,
          "type": "student",
          "name": "user - 8",
          "gender": "female"
        },
        {
          "id": 9,
          "age": 20,
          "type": "student",
          "name": "user - 9",
          "gender": "female"
        },
        {
          "id": 10,
          "age": 20,
          "type": "student",
          "name": "user - 10",
          "gender": "female"
        }
      ]
    }
  },
  "male": {
    "18": {
      "student": [
        {
          "id": 1,
          "age": 18,
          "type": "student",
          "name": "user - 1",
          "gender": "male"
        },
        {
          "id": 3,
          "age": 18,
          "type": "student",
          "name": "user - 3",
          "gender": "male"
        },
        {
          "id": 4,
          "age": 18,
          "type": "student",
          "name": "user - 4",
          "gender": "male"
        }
      ]
    },
    "20": {
      "student": [
        {
          "id": 2,
          "age": 20,
          "type": "student",
          "name": "user - 2",
          "gender": "male"
        },
        {
          "id": 7,
          "age": 20,
          "type": "student",
          "name": "user - 7",
          "gender": "male"
        }
      ]
    },
    "35": {
      "teacher": [
        {
          "id": 5,
          "age": 35,
          "type": "teacher",
          "name": "user - 5",
          "gender": "male"
        },
        {
          "id": 6,
          "age": 35,
          "type": "teacher",
          "name": "user - 6",
          "gender": "male"
        }
      ]
    }
  }
}

可以看到,原先的List数据,按照gender/age/type三个属性,分成了三层的Map,对于这种多层的Map代码上处理起来会有一些不方便。并且如果分组字段更多的话,所嵌套的Collectors.groupingBy也会更加多,代码书写起来也不太优雅。

下面将介绍另外一种按多字段分组的方法。

3. 利用Collectors.groupingBy与Function结合进行多字段分组

查看Collectors.groupingByAPI会发现,其中一种用法是第一个参数为Function,如下:
stream多字段分组,java,后端,stream
简单翻译一下就是:一种将输入元素映射到键的分类函数。即需要定义一个函数Function,该函数将元素对象映射到一个键的集合里。代码示例如下:

public class TestGroupingBy {

    public static void main(String[] args) {

        List<Person> personList = Arrays.asList(
                new Person().setId(1).setAge(18).setType("student").setName("user - 1").setGender("male"),
                new Person().setId(2).setAge(20).setType("student").setName("user - 2").setGender("male"),
                new Person().setId(3).setAge(18).setType("student").setName("user - 3").setGender("male"),
                new Person().setId(4).setAge(18).setType("student").setName("user - 4").setGender("male"),
                new Person().setId(5).setAge(35).setType("teacher").setName("user - 5").setGender("male"),
                new Person().setId(6).setAge(35).setType("teacher").setName("user - 6").setGender("male"),
                new Person().setId(7).setAge(20).setType("student").setName("user - 7").setGender("male"),
                new Person().setId(8).setAge(20).setType("student").setName("user - 8").setGender("female"),
                new Person().setId(9).setAge(20).setType("student").setName("user - 9").setGender("female"),
                new Person().setId(10).setAge(20).setType("student").setName("user - 10").setGender("female")
        );

        // 定义一个函数Function,该函数将元素对象映射到一个键的集合里
        Function<Person, List<Object>> compositeKey = person ->
                Arrays.asList(person.getGender(), person.getAge(), person.getType());

        // 分组
        Map<List<Object>, List<Person>> groupingMap =
                personList.stream().collect(Collectors.groupingBy(compositeKey, Collectors.toList()));

    }
}

通过在Debug模式下运行代码,可以看到groupingMap的数据结构如下:
stream多字段分组,java,后端,stream
groupingMap数据仅仅只有一层,但是其键值Key却是一个List,里面包含了分组字段的值,如上图中的male35teacher是集合中属性gender/age/type分别是male35teacher的元素集合。数据按Json格式贴出如下:

{
  "[male, 35, teacher]": [
    {
      "id": 5,
      "age": 35,
      "type": "teacher",
      "name": "user - 5",
      "gender": "male"
    },
    {
      "id": 6,
      "age": 35,
      "type": "teacher",
      "name": "user - 6",
      "gender": "male"
    }
  ],
  "[female, 20, student]": [
    {
      "id": 8,
      "age": 20,
      "type": "student",
      "name": "user - 8",
      "gender": "female"
    },
    {
      "id": 9,
      "age": 20,
      "type": "student",
      "name": "user - 9",
      "gender": "female"
    },
    {
      "id": 10,
      "age": 20,
      "type": "student",
      "name": "user - 10",
      "gender": "female"
    }
  ],
  "[male, 20, student]": [
    {
      "id": 2,
      "age": 20,
      "type": "student",
      "name": "user - 2",
      "gender": "male"
    },
    {
      "id": 7,
      "age": 20,
      "type": "student",
      "name": "user - 7",
      "gender": "male"
    }
  ],
  "[male, 18, student]": [
    {
      "id": 1,
      "age": 18,
      "type": "student",
      "name": "user - 1",
      "gender": "male"
    },
    {
      "id": 3,
      "age": 18,
      "type": "student",
      "name": "user - 3",
      "gender": "male"
    },
    {
      "id": 4,
      "age": 18,
      "type": "student",
      "name": "user - 4",
      "gender": "male"
    }
  ]
}

由于Map只有一层,用该方式分组的结果,对于我们业务也是比较友好,代码里对数据处理起来也是比较方便的。可以看到,从代码书写角度以及分组处理后得到的结果,该方法都是最优雅的。

写在最后

可以看到,如果分组字段只有一个,我们可以用比较简单的利用Stream.collect()Collectors.groupingBy进行处理,但对于多个字段的分组操作,建议还是用Collectors.groupingByFunction进行处理。文章来源地址https://www.toymoban.com/news/detail-535002.html

到了这里,关于Java stream多字段分组(groupingBy)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java8 Stream分组groupBy后,取单一字段值、取列表第一个值方式

    java8 Stream中groupBy的拓展用法。 取单一字段值、取列表第一个值方式

    2024年02月14日
    浏览(39)
  • java根据分组函数GroupingBy进行多个条件组合分组

    在SQL中经常会用到分组,我们也常常遇到一些组合分组的场景。 java8分组 传统写法(单个字段分组) 场景:根据 城市 进行分组 使用的是方法引用:User::getCity 来完成分组 java8分组 传统写法(多个字段分组) 场景:根据 城市,性别进行分组 一般的写法会是下面的这种写法,

    2023年04月19日
    浏览(43)
  • Java8使用stream流给List<Map<String,Object>>分组(多字段key)

    Java8使用 stream流 给ListMapString,Object根据字段key 分组 一、项目场景: 从已得到的List集合中,根据某一元素(这里指map的key)进行分组,筛选出需要的数据。 如果是SQL的话则使用 group by 直接实现,代码的方式则如下: 使用到stream流的 Collectors.groupingBy() 方法。 二、代码实现 1、首

    2024年02月02日
    浏览(65)
  • Java stream 分组操作

    根据单/多字段分组 单字段分组可以直接使用指定字段,多字段分组则采用拼接Key的形式 单字段: 多字段: 多层级: 测试

    2024年02月15日
    浏览(41)
  • java stream实现分组BigDecimal求和,自定义分组求和

    随着微服务的发展,越来越多的sql处理被放到java来处理,数据库经常会使用到对集合中的数据进行分组求和,分组运算等等。 那怎么样使用java的stream优雅的进行分组求和或运算呢? 这里测试数据学生,年龄类型是Integer,身高类型是BigDecimal,我们分别对身高个年龄进行求和

    2024年02月01日
    浏览(45)
  • Java Stream流 Map 分组方式汇总

    java老式的分组方式(对list for循环然后 if判断 放入map) 代码复杂,易读性差,维护性差,故本文汇总了Stream流中的分组方法供大家参考,如对您有帮助,请抬抬高贵的小手点个赞吧,欢迎大佬留下高见 (以下方法默认都是java8的方法,java9新增方法有标注) 按颜色分组 打印Map结果: {红色

    2024年02月06日
    浏览(42)
  • Java Stream 处理分组后取每组最大&Stream流之list转map、分组取每组第一条&Java 8 Collectors:reducing 示例(List分组取最值)

    有一个需求功能:先按照某一字段分组,再按照另外字段获取最大的那个 先根据appId分组,然后根据versionSort取最大. JDK1.8推出的stream流能极大的简化对集合的操作,让代码更美观,老规矩,直接上代码。 取list中对象的某个属性作为唯一key,对象作为value形成一个map集合,能

    2024年02月16日
    浏览(60)
  • Es Java多字段分组查询

    es按照多个字段分组查询 java 代码实现:

    2024年02月12日
    浏览(50)
  • Java中用Stream分组并求各组数量

    比如给了我一个班级的所有人的姓氏和姓名对象集合,根据这个集合求出各姓氏有多少人。直接上代码。 User的实体类对象为 输出的结果为:   即姓张的有3个,姓李的有两个。 详解: 将该集合的stream流用Collectors对象转成Map,用User对象的firstName作为Key,默认键值为1,在处

    2024年02月12日
    浏览(41)
  • Java Stream 实用特性:排序、分组和 teeing

    基本数据类型排序 基本数据类型就是字符串、整型、浮点型这些,也就是要排序的列表中的元素都是这些基本类型的,比如 ListInteger 的。 下面就用一个整型列表举例说明。 正序排序 正序排序,也可以叫做按照自然顺序排序,对于整型来说就是从小到大的。 输出结果是 [0

    2024年02月03日
    浏览(50)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包