Java8 Stream 之groupingBy 分组讲解

最新推荐文章于 2024-08-17 23:17:28 发布
最新推荐文章于 2024-08-17 23:17:28 发布
阅读量7.7k 收藏 9
点赞数 4
文章标签： windows python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36577291/article/details/132236281
版权

本文主要讲解：Java 8 Stream之Collectors.groupingBy()分组示例

Collectors.groupingBy() 分组之常见用法
功能代码:

/**
     * 使用java8 stream groupingBy操作,按城市分组list
     */
    public void groupingByCity() {
        Map<String, List<Employee>> map = employees.stream().collect(Collectors.groupingBy(Employee::getCity));
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
Collectors.groupingBy() 分组之统计每个分组的count
功能代码:

/**
     * 使用java8 stream groupingBy操作,按城市分组list统计count
     */
    public void groupingByCount() {
        Map<String, Long> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getCity, Collectors.counting()));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
Collectors.groupingBy() 分组之统计分组平均值
功能代码:

/**
     * 使用java8 stream groupingBy操作,按城市分组list并计算分组年龄平均值
     */
    public void groupingByAverage() {
        Map<String, Double> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getCity, Collectors.averagingInt(Employee::getAge)));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
Collectors.groupingBy() 分组之统计分组总值
功能代码:

/**
     * 使用java8 stream groupingBy操作,按城市分组list并计算分组销售总值
     */
    public void groupingBySum() {
        Map<String, Long> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getCity, Collectors.summingLong(Employee::getAmount)));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
 
        // 对Map按照分组销售总值逆序排序
        Map<String, Long> sortedMap = new LinkedHashMap<>();
        map.entrySet().stream().sorted(Map.Entry.<String, Long> comparingByValue().reversed())
                .forEachOrdered(e -> sortedMap.put(e.getKey(), e.getValue()));
 
        sortedMap.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }

Collectors.groupingBy() 分组之Join分组List
功能代码:

/**
     * 使用java8 stream groupingBy操作,按城市分组list并通过join操作连接分组list中的对象的name 属性使用逗号分隔
     */
    public void groupingByString() {
        Map<String, String> map = employees.stream().collect(Collectors.groupingBy(Employee::getCity,
                Collectors.mapping(Employee::getName, Collectors.joining(", ", "Names: [", "]"))));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
Collectors.groupingBy() 分组之转换分组结果List -> List
功能代码:

/**
     * 使用java8 stream groupingBy操作,按城市分组list,将List转化为name的List
     */
    public void groupingByList() {
        Map<String, List<String>> map = employees.stream().collect(
                Collectors.groupingBy(Employee::getCity, Collectors.mapping(Employee::getName, Collectors.toList())));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
            v.stream().forEach(item -> {
                System.out.println("item = " + item);
            });
        });
    }
Collectors.groupingBy() 分组之转换分组结果List -> Set
功能代码:

/**
     * 使用java8 stream groupingBy操作,按城市分组list,将List转化为name的Set
     */
    public void groupingBySet() {
        Map<String, Set<String>> map = employees.stream().collect(
                Collectors.groupingBy(Employee::getCity, Collectors.mapping(Employee::getName, Collectors.toSet())));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
            v.stream().forEach(item -> {
                System.out.println("item = " + item);
            });
        });
    }
Collectors.groupingBy() 分组之使用对象分组List
功能代码:

/**
     * 使用java8 stream groupingBy操作,通过Object对象的成员分组List
     */
    public void groupingByObject() {
        Map<Manage, List<Employee>> map = employees.stream().collect(Collectors.groupingBy(item -> {
            return new Manage(item.getName());
        }));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
Collectors.groupingBy() 分组之使用两个成员分组List
功能代码:

/**
     * 使用java8 stream groupingBy操作, 基于city 和name 实现多次分组
     */
    public void groupingBys() {
        Map<String, Map<String, List<Employee>>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getCity, Collectors.groupingBy(Employee::getName)));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
            v.forEach((i, j) -> {
                System.out.println(i + " = " + j);
            });
        });
    }
自定义Distinct对结果去重
功能代码

/**
     * 使用java8 stream groupingBy操作, 基于Distinct 去重数据
     */
    public void groupingByDistinct() {
        List<Employee> list = employees.stream().filter(distinctByKey(Employee :: getCity))
                .collect(Collectors.toList());;
 
        list.stream().forEach(item->{
            System.out.println("city = " + item.getCity());
        });
        
        
    }
 
    /**
     * 自定义重复key 规则
     * @param keyExtractor
     * @return
     */
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Set<Object> seen = ConcurrentHashMap.newKeySet();
        return t -> seen.add(keyExtractor.apply(t));
    }
完整源代码：

package com.stream;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
 
/**
 * Java 8 Stream 之groupingBy 分组讲解
 * 
 * @author zzg
 *
 */
public class Java8GroupBy {
 
    List<Employee> employees = new ArrayList<Employee>();
 
    /**
     * 数据初始化
     */
    public void init() {
        List<String> citys = Arrays.asList("湖南", "湖北", "江西", "广西 ");
        for (int i = 0; i < 10; i++) {
            Random random = new Random();
            Integer index = random.nextInt(4);
            Employee employee = new Employee(citys.get(index), "姓名" + i, (random.nextInt(4) * 10 - random.nextInt(4)),
                    (random.nextInt(4) * 1000 - random.nextInt(4)));
            employees.add(employee);
        }
    }
 
    /**
     * 使用java8 stream groupingBy操作,按城市分组list
     */
    public void groupingByCity() {
        Map<String, List<Employee>> map = employees.stream().collect(Collectors.groupingBy(Employee::getCity));
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作,按城市分组list统计count
     */
    public void groupingByCount() {
        Map<String, Long> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getCity, Collectors.counting()));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作,按城市分组list并计算分组年龄平均值
     */
    public void groupingByAverage() {
        Map<String, Double> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getCity, Collectors.averagingInt(Employee::getAge)));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作,按城市分组list并计算分组销售总值
     */
    public void groupingBySum() {
        Map<String, Long> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getCity, Collectors.summingLong(Employee::getAmount)));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
 
        // 对Map按照分组销售总值逆序排序
        Map<String, Long> sortedMap = new LinkedHashMap<>();
        map.entrySet().stream().sorted(Map.Entry.<String, Long> comparingByValue().reversed())
                .forEachOrdered(e -> sortedMap.put(e.getKey(), e.getValue()));
 
        sortedMap.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作,按城市分组list并通过join操作连接分组list中的对象的name 属性使用逗号分隔
     */
    public void groupingByString() {
        Map<String, String> map = employees.stream().collect(Collectors.groupingBy(Employee::getCity,
                Collectors.mapping(Employee::getName, Collectors.joining(", ", "Names: [", "]"))));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作,按城市分组list,将List转化为name的List
     */
    public void groupingByList() {
        Map<String, List<String>> map = employees.stream().collect(
                Collectors.groupingBy(Employee::getCity, Collectors.mapping(Employee::getName, Collectors.toList())));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
            v.stream().forEach(item -> {
                System.out.println("item = " + item);
            });
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作,按城市分组list,将List转化为name的Set
     */
    public void groupingBySet() {
        Map<String, Set<String>> map = employees.stream().collect(
                Collectors.groupingBy(Employee::getCity, Collectors.mapping(Employee::getName, Collectors.toSet())));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
            v.stream().forEach(item -> {
                System.out.println("item = " + item);
            });
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作,通过Object对象的成员分组List
     */
    public void groupingByObject() {
        Map<Manage, List<Employee>> map = employees.stream().collect(Collectors.groupingBy(item -> {
            return new Manage(item.getName());
        }));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作, 基于city 和name 实现多次分组
     */
    public void groupingBys() {
        Map<String, Map<String, List<Employee>>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getCity, Collectors.groupingBy(Employee::getName)));
 
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
            v.forEach((i, j) -> {
                System.out.println(i + " = " + j);
            });
        });
    }
 
    /**
     * 使用java8 stream groupingBy操作, 基于Distinct 去重数据
     */
    public void groupingByDistinct() {
        List<Employee> list = employees.stream().filter(distinctByKey(Employee :: getCity))
                .collect(Collectors.toList());;
 
        list.stream().forEach(item->{
            System.out.println("city = " + item.getCity());
        });
        
        
    }
 
    /**
     * 自定义重复key 规则
     * @param keyExtractor
     * @return
     */
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Set<Object> seen = ConcurrentHashMap.newKeySet();
        return t -> seen.add(keyExtractor.apply(t));
    }
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Java8GroupBy instance = new Java8GroupBy();
        instance.init();
        instance.groupingByCity();
        instance.groupingByCount();
        instance.groupingByAverage();
        instance.groupingBySum();
        instance.groupingByString();
        instance.groupingByList();
        instance.groupingBySet();
        instance.groupingByObject();
        instance.groupingBys();
        instance.groupingByDistinct();
 
    }
 
    class Employee {
        private String city;
        private String name;
        private Integer age;
        private Integer amount;
 
        public String getCity() {
            return city;
        }
 
        public void setCity(String city) {
            this.city = city;
        }
 
        public String getName() {
            return name;
        }
 
        public void setName(String name) {
            this.name = name;
        }
 
        public Integer getAge() {
            return age;
        }
 
        public void setAge(Integer age) {
            this.age = age;
        }
 
        public Integer getAmount() {
            return amount;
        }
 
        public void setAmount(Integer amount) {
            this.amount = amount;
        }
 
        public Employee(String city, String name, Integer age, Integer amount) {
            super();
            this.city = city;
            this.name = name;
            this.age = age;
            this.amount = amount;
        }
 
        public Employee() {
            super();
        }
    }
 
    class Manage {
        private String name;
 
        public String getName() {
            return name;
        }
 
        public void setName(String name) {
            this.name = name;
        }
 
        public Manage(String name) {
            super();
            this.name = name;
        }
 
        public Manage() {
            super();
        }
    }
 
}
github 地址: 待补全

本文参考：
————————————————
版权声明：本文为CSDN博主「在奋斗的大道」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhouzhiwengang/article/details/112319054

蹦跶de芝麻
关注
高薪程序员&面试题精讲系列26之介绍一下Java8中的Stream流
一一哥
11-29 1458
一. 面试题及剖析 1. 今日面试题 在上一篇文章中，壹哥 给各位介绍了Java中的新特性，其中的一个重要特性就是Stream流。因为Stream流可以大幅提高我们操作集合的并发效率和安全性，所以面试时也是一个高频考点，题目如下： 请你介绍一下Java 8中的Stream流 2. 题目剖析 我们在进行Java开发时，集合(List/Set/Map/Array)编码是非常常见的操作。而Stream则是Java 8中提供的用于操作集合的一个利器，可以极大提高集合的并发操作效率，还可以保证线程安全性
java8实战：使用流收集数据之toList、joining、groupBy(多字段分组)
CSDN_KONGlX的博客
07-10 3784
java8专栏目录：java8实战读书笔记：Lambda表达式语法与函数式编程接口java8实战读书笔记：复合Lambda表达式java8实战读书笔记：初识Stream、流的基本操作(流计算)java8实战读书笔记：数值流、Stream创建与Optional类的使用java8读书笔记：探究java8流收集数据原理本文将从Collectos中构建收集器入手，详细介绍java8提供了哪些收集器，重点...
Java8Streams流groupBy详解
m0_71777195的博客
07-29 5607
我已经在本文中尽可能详细地解释了 Collectors 类分组操作相关的 3 个方法，希望您能在日常编程中理解并使用它。
Java8的stream之groupingBy()分组排序
李长渊的博客
09-20 1万+
Java8的stream之groupingBy()分组排序
Java8提供的Stream方式进行分组GroupingBy
最新发布
wang_666_888的博客
08-17 395
有时我们需要对集合进行分组操作，这时可以使用Java8提供的Stream方式进行分组。挺好用的，此处记录下。
Java笔记--Stream之groupingBy 分组讲解
Schaffer的博客
08-18 4891
本文主要讲解：Java 8 Stream之Collectors.groupingBy()分组示例 Collectors.groupingBy() 分组之常见用法 功能代码: /** * 使用java8 stream groupingBy操作,按城市分组list */ public void groupingByCity() { Map<String, List<Employee>> map = employees.stream().collect(Collectors.
Stream流之groupingBy分组详解 (java1.8 新特性)
weixin_46887062的博客
09-13 8654
(使用java8 stream groupingBy操作, 基于city 和name 实现多次分组)/*** 自定义重复key 规则* @return*/super T,?;});希望对大家有帮助 下期再见呦~Java8 Stream 之groupingBy 分组讲解_在奋斗的大道的博客-CSDN博客。
归约、分组与分区，深入讲解JavaStream终结操作
A1867350的博客
04-21 1034
对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！正体系化！**
Java Stream全面讲解
06-23
Stream API首次在Java 8中引入，极大地提升了代码的简洁性和可读性。 Java中的Stream分为两种类型：InputStream和OutputStream，分别对应输入流和输出流。InputStream用于读取数据，而OutputStream则用于写入数据。...
Java8-Stream 流基本应用-groupBy进行分组
康世行
01-28 2249
【代码】Java8-Stream 流基本应用-groupBy进行分组。
JAVA8 STREAM COLLECT GROUPBY分组实例解析
08-25
主要介绍了JAVA8 STREAM COLLECT GROUPBY分组实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java8 stream 中利用 groupingBy 进行多字段分组求和案例
09-07
主要介绍了Java8 stream 中利用 groupingBy 进行多字段分组求和案例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
笔记--对List进行分组（java8的Stream 分组的groupBy 的使用）
weixin_43103583的博客
09-30 1万+
对List进行分组（java8的Stream 分组的groupBy 的使用） 最近在做一个功能：对一个接口接收的List数据进行校验，同一个订单里的一个产品id只能添加一次。本来想是在入库的时候通过SQL语句进行处理的。但是由于这个数据接口之前同事写了很多的校验，是在是又*又长。在度娘上查一下，发现了JAVA8 可以通过Stream对List进行处理（这里主要是关于分组的）； Order order1 = new Order(); order1.setOrderId("123")； Order1.
java8 分组（groupingBy）
qq_43722564的博客
06-19 902
//查询需要出库数量 Map<String, BigDecimal> collectList = list.stream().collect(Collectors.groupingBy(o -> { return String.format("%s_%s_%s", o.getProductId(), o.getRepertoryId(), o.getUnitId());...
Java8的stream流分组
weixin_52796198的博客
05-15 1731
作为Java8的新生代的一员大将Stream流 作为新老程序员我觉得应该都需要牢牢掌握这个技术，当然现在也已经距离stream流出现很久了，不过目前作为最高效的处理集合方式，平时可以用来获取集合中的某一列数据啊、统计同一个字段的总数啊之类的，不过有时候需求需要用到分组而sql里不能直接分组的情况下，使用stream流来进行分组是最好不过的了。直接把里面的某个字段直接提取到最外面来进行分组，每个map的key值就是这个字段的值，当然如果存在空值还需要额外处理噢。那么根据分组之后，它就可以长成这样。
Java8 stream流之分组 groupingBy 的使用
热门推荐
suge大帝的博客
06-10 4万+
使用stream流可以让我们的代码看上去很简洁，本文举例了 按照班级分组、分组再过滤、统计分组后人数、嵌套分组、分组排序...
Java8 Stream集合的筛选、归约、分组、聚合讲解
码灵的博客
01-09 2407
因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的 Lambda ，给我们操作集合（Collection）提供了极大的便利。Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
Java8 stream 中利用 groupingBy 进行多字段分组求和
07-28
在Java 8的Stream中，可以使用groupingBy方法进行多字段分组求和。首先，我们需要创建一个包含对象的集合，然后使用stream方法将其转换为流。接下来，我们可以使用groupingBy方法来指定多个字段作为分组条件。每个字段都可以通过lambda表达式来指定。最后，我们可以使用collect方法来收集结果。 示例代码如下： ``` List<Item> items = Arrays.asList( new Item("apple", "China"), new Item("apple", "USA"), new Item("banana", "China"), new Item("banana", "USA"), new Item("orange", "China"), new Item("orange", "USA") ); Map<String, Map<String, Long>> result = items.stream() .collect(Collectors.groupingBy(Item::getProductType, Collectors.groupingBy(Item::getCountry, Collectors.counting()))); System.out.println(result); ``` 在这个示例中，我们创建了一个包含产品类型和国家的Item对象集合。然后，我们使用stream方法将其转换为流。接下来，我们使用groupingBy方法指定了两个字段作为分组条件，即产品类型和国家。最后，我们使用collect方法来收集结果，并将结果存储在一个嵌套的Map中，其中外层的键是产品类型，内层的键是国家，值是对应的计数。 输出结果将会是一个嵌套的Map，其中外层的键是产品类型，内层的键是国家，值是对应的计数。 #### 引用[.reference_title] - *1* *3* [Java8 stream 中利用 groupingBy 进行多字段分组求和](https://blog.csdn.net/lizhengyu891231/article/details/108997080)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Java8 stream 中利用 groupingBy 进行多字段分组](https://blog.csdn.net/weixin_39637363/article/details/113543899)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值