collect流收集器详解 java8（附代码）

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量1.7k 收藏 55
点赞数 83
分类专栏： Java那些事 文章标签： java 笔记 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LYGCSDN_/article/details/140398538
版权

🍰 个人主页:_小白不加班__
🍞文章有不合理的地方请各位大佬指正。
🍉文章不定期持续更新，如果我的文章对你有帮助➡️ 关注🙏🏻 点赞👍 收藏⭐️

文章目录

一、收集器常用api

在这里插入图片描述
在这里插入图片描述

二、收集器常用静态方法的代码举例

使用上述收集解决一下问题：

使用收集器静态方法收集如下数据：

  1. 所有商品名称的集合
  2. 获取所有商品类型
  3. 在"水果"分类中有几种商品
  4. "水果"分类平均价格
  5. 求所有商品 总库存量
  6. 将所有水果名称 连起来，中间用逗号隔开
  7. 库存最多的商品
  8. 库存最少的商品
  9. 按类别分组，相同类别的商品存放到同一个集合中
    求出每个类别各有多少种商品
    求出每个类别 拥有最大库存数的商品
  10. 按谓词分组,筛选库存量 大于350和 小于于等于350 分为两组

1. toList()

所有商品名称的集合

/**
* 所有商品名称的集合
*/
@Test
public void streamDemo110() {
   List<Product> products = new ArrayList<>();
   // id  name description price stockQuantity category
   products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
   products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
   products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
   products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
   List<String> names = products.stream().map(Product::getName).collect(toList());
   System.out.println(names);// [苹果, 香蕉, 帽子, 上衣]
}

2. toSet()

获取所有产品类型名称

 /**
 * 获取所有产品类型
 */
@Test
public void streamDemo111() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    Set<String> category = products.stream().map(Product::getCategory).collect(toSet());
    System.out.println(category);// [水果, 衣服]
}

3. counting()

求有几种水果

/**
 * 求有几种水果
 */
@Test
public void streamDemo112() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    Long num = products.stream()
            .filter(p -> "水果".equals(p.getCategory()))
            .collect(counting());
    System.out.println("有" + num+"种水果");//有2种水果
}

4. averagingDouble()

水果平均价格

 /**
 * 求"水果"的评价价格
 */
@Test
public void streamDemo114() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    Double avg = products.stream()
            .filter(p -> "水果".equals(p.getCategory()))
            .collect(averagingDouble(Product::getPrice));
    System.out.println("水果平均价格:"+avg);//水果平均价格:75.0
}

5. summingInt()

求所有商品 总库存量

 /**
 * 求所有商品 总库存量
 */
@Test
public void streamDemo113() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    Integer stock2 = products.stream().collect(summingInt(Product::getStockQuantity));
    System.out.println("库存量：" + stock2);// 库存量：1000
}

6. joining()

将所有水果名称 连起来

 /**
 * 将所有水果名称 连起来
 */
@Test
public void streamDemo115() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    String names = products.stream()
            .filter(p -> "水果".equals(p.getCategory()))
            .map(Product::getName).collect(joining(","));
    System.out.println(names);// 苹果,香蕉
}

7. maxBy()

库存最多的商品

 /**
 * 获取商品集合中 最大库存数
 */
@Test
public void streamDemo116() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    Optional<Product> collect = products.stream()
            .collect(maxBy(comparing(Product::getStockQuantity)));
    System.out.println("库存最多的商品："+collect.get().getName());
    //库存最多的商品：上衣
}

8. minBy()

库存最少的商品

 /**
 * 获取商品集合中 最大库存数
 */
@Test
public void streamDemo116() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    Optional<Product> collect = products.stream()
            .collect(minBy(comparing(Product::getStockQuantity)));
    System.out.println("库存最少的商品："+collect.get().getName());
    //库存最少的商品：苹果
}

9. groupingBy()

按属性分组
按类别分组，相同类别的商品存放到同一个集合中

/**
 *  按类别分组，相同类别的商品存放到同一个集合中
*/
@Test
public void streamDemo181() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    Map<String,List<Product>> map = products.stream().collect(groupingBy(Product::getCategory));

    map.forEach((k,v)->{
        System.out.println(k+"====="+v);
    });
    /*
    水果=====[Product(id=1, name=苹果, description=好吃的苹果, price=100.0, stockQuantity=100, category=水果),
     Product(id=2, name=香蕉, description=好吃的香蕉, price=50.0, stockQuantity=200, category=水果)]
    衣服=====[Product(id=3, name=帽子, description=帽子, price=80.0, stockQuantity=300, category=衣服),
     Product(id=4, name=上衣, description=上衣, price=60.0, stockQuantity=400, category=衣服)]
    * */
}
groupingBy()拓展使用
  1. groupingBy(Function, Collector)
  2. 第二个参数可以接受上面任意一个收集器静态方法

求出每个类别各有多少种商品
求出每个类别 拥有最大库存数的商品

/**
 * 求出每个类别各有多少种商品
 * 求出每个类别 拥有最大库存数的商品
 */

@Test
public void streamDemo21() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    // 求出每个类别各有多少种商品
    Map<String, Long> map = products.stream().collect(groupingBy(Product::getCategory, counting()));
    map.forEach((k, v) -> {
        System.out.println(k + "有" + v+"种商品");
        // 水果有2种商品
        // 衣服有2种商品
    });
    // 求出每个类别 拥有最大库存数的商品
    Map<String,Optional <Product>> map1 = products.stream().collect(groupingBy(Product::getCategory, maxBy(comparingInt(Product::getStockQuantity))));
    map1.forEach((k,v)->{
        System.out.println("【"+k+"】库存最多的商品："+v.get().getName()+",库存量："+v.get().getStockQuantity());
        //【水果】库存最多的商品：香蕉,库存量：200
        //【衣服】库存最多的商品：上衣,库存量：400
});

10. partitioningBy()

分区：按谓词分组,筛选库存量 大于350和 小于于等于350 分为两组

/**
 * 按谓词分组,筛选库存量 大于350和 小于于等于350 分为两组
 */
@Test
public void streamDemo1181() {
    List<Product> products = new ArrayList<>();
    products.add(new Product(1L, "苹果", "好吃的苹果", 100.0, 100, "水果"));
    products.add(new Product(2L, "香蕉", "好吃的香蕉", 50.0, 200, "水果"));
    products.add(new Product(3L, "帽子", "帽子", 80.0, 300, "衣服"));
    products.add(new Product(4L, "上衣", "上衣", 60.0, 400, "衣服"));
    Map<Boolean, List<Product>> map = products.stream().collect(partitioningBy(p -> stockGt350(p)));
    map.forEach((k, v) -> {
        System.out.println(k + "=====" + v);
    });
    /**
     * false=====[Product(id=1, name=苹果, description=好吃的苹果, price=100.0, stockQuantity=100, category=水果),Product(id=2, name=香蕉, description=好吃的香蕉, price=50.0, stockQuantity=200, category=水果), Product(id=3, name=帽子, description=帽子, price=80.0, stockQuantity=300, category=衣服)]
     * true=====[Product(id=4, name=上衣, description=上衣, price=60.0, stockQuantity=400, category=衣服)]
     */
}
public boolean stockGt350(Product product) {
    return product.getStockQuantity() > 350;
}

三、广义归约Collectors.reducing 在收集器中的使用场景和案例

上一篇文章《reduce归约：深入理解java8中的归约reduce》提到了reduce中间操作的使用规则，这次reducing是作为终端操作，在搜集器中使用。

收集器常用api都是Collectors.reducing的特殊情况

1. reducing(BinaryOperator)

流中的前两个元素进行累积计算

/**
 * 工资最高人的姓名
 */
@Test
public void streamDemo1081() {
    List<Worker> workers = new ArrayList<>();
    workers.add(new Worker("张三", 1000, 20, Arrays.asList(1, 2, 45, 23, 22)));
    workers.add(new Worker("李四", 2000, 30, Arrays.asList(10, 20, 450, 230, 220)));
    Optional<Worker> worker = workers.stream()
            .collect(reducing((w1, w2) -> w1.getSalary() > w2.getSalary() ? w1 : w2));
    System.out.println("工资最高："+worker.get().getName());//工资最高：李四
}
2. reducing(Object, BinaryOperator)
  1. 此方法接受一个初始值（T）和一个二元操作符（BinaryOperator<T>）
  2. 首先使用初始值作为累积器的初始值，然后将流中的元素依次与累积器的当前值进行累积计算。

//计算整数流中所有偶数元素的和
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenSums = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.reducing(0, Integer::sum));
System.out.println("Even sums: " + evenSums); // 输出：Even sums: [6]
3. reducing(Object, Function, BinaryOperator)
  1. 此方法接受一个初始值（U）、一个映射函数（Function<U, ? super T, U>）和一个二元操作符（BinaryOperator<U>）
  2. 首先使用初始值作为累积器的初始值，然后将流中的元素依次应用映射函数，并将映射函数的结果与累积器的当前值进行累积计算。
/**
 * 发放工资总和
 */
@Test
public void streamDemo1081() {
    List<Worker> workers = new ArrayList<>();
    workers.add(new Worker("张三", 1000, 20, Arrays.asList(1, 2, 45, 23, 22)));
    workers.add(new Worker("李四", 2000, 30, Arrays.asList(10, 20, 450, 230, 220)));
    Integer countSalary = workers.stream()
            .collect(reducing(0, Worker::getSalary, (x, y) -> x + y));
    System.out.println("总发放：" + countSalary + "元");// 总发放：3000元
    // 等价于 workers.stream().collect(summingInt(Worker::getSalary)); 
}

参考：《java8 实战》

🍉文章不定期持续更新，如果我的文章对你有帮助➡️ 关注🙏🏻 点赞👍 收藏⭐️

小白不加班
关注
专栏目录
实用的 Java 8 Stream 代码
04-30
实用的 Java 8 Stream 代码
Java8的流Stream与收集器Collector详解
zw19910924的专栏
08-08 1万+
流Stream概述Stream可以说是java8的一大亮点。java8中的Stream对集合功能进行了增强。在日常开发中，我们免不了要经常对集合对象进行处理，而在java8以前，对于集合的处理完全是由我们自己来操作，所以代码看起来相对繁杂。而有了Stream以后，对于集合的处理得到了大大的简化。Stream提供了对集合对象的各种非常便利的、高效的聚合操作。集合和Stream，表面看起来很相似，却有着
Java Stream流详解
唯有努力，方可自信！
06-10 3万+
Java Stream流是一种非常强大和灵活的数据处理工具，可以帮助开发人员轻松处理和转换数据。Stream流支持丰富多样的操作方法，如filter()、map()、reduce()等，能够简化代码，提高效率和可读性。在多线程场景下，Stream流更是发挥了现代多核处理器的优势，可以获得更好的性能表现。本文从基础入门到进阶特点为读者介绍Java Stream流的相关知识。
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 8万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
JAVA8专题-Stream流操作详解
逆天-逍遥哥哥的博客
07-17 1702
JAVA8专题-Stream流操作详解
探索Java Stream流：概念、应用与代码示例详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-30 4万+
Java Stream流为处理集合数据提供了强大的工具集，其声明式、延迟计算和可并行化的特性使得代码更为简洁、高效。通过熟练掌握Stream API的使用，开发者能够编写出易于理解、易于维护且高性能的Java程序。在实际项目中，应根据具体需求灵活运用Stream的各种操作，同时注意衡量并行流的收益与成本，以达到最佳的编程效果。持续实践与探索，将使您在Java编程中充分受益于Stream流的强大功能。
Java8新特性Stream流详解
陈老老老板的博客
10-25 2万+
既然我们已经知道了这些强大的内置收集器，接下来就让我们尝试构建自定义收集器吧。比如说，我们希望将流中的所有人转换成一个字符串，包含所有大写的名称，并以|分割。为了达到这种效果，我们需要通过Collector.of()创建一个新的收集器。同时，我们还需要传入收集器的四个组成部分：供应器、累加器、组合器和终止器。
详解Java8 Collect收集Stream的方法
johnhuster的专栏
07-19 8084
转载自：https://www.jb51.net/article/138519.htm 这篇文章主要介绍了Java8-Collect收集Stream的方法，提到了收集器的作用，连接收集器的方法,需要的朋友可以参考下 Collection, Collections, collect, Collector, Collectos Collection是Java集合的祖先接口。 Collection...
Java8实战-函数式数据处理-Steam流之收集器接口
weixin_42872138的博客
07-21 200
下面的代码为Collector接口的定义，列出了接口的签名以及声明的五个方法。 例如，你可以实现一个==ToListCollector==类，将Stream中的所有元素收集到一个 List里，它的签名如下: 建立新的结果容器:supplier方法 ToListCollector中，supplier返回一个空的List，如下所示: 将元素添加到结果容器:accumulator方法 对于ToListCollector，这个函数仅仅会把当前项目添加至已经遍历过的项目的列表: 对结果
java 8如何自定义收集器（collector）详解
08-30
Java 8 自定义收集器（Collector） Java 8 中的 Collector 是一个功能强大且灵活的工具，允许用户自定义收集器来满足特定的需求。在本文中，我们将详细介绍如何自定义收集器，以满足特定的业务需求。 Collector ...
java8自定义收集器_JAVA 8函数式编程（五）：收集器详解与自定义实现
weixin_39801465的博客
03-07 110
在Stream的接口中，最强大的接口就是collect了，当然这也是最难的接口，它对Stream的应用过程可分为四步：1. 利用Supplier接口，创建存储中间运算结果的容器(不是返回结果)，扮演的角色为supplier；2. 利用BiConsumer// 声明单词集合对象List words = Lists.newArrayList("hi", "Hello", "Hi", "hello",...
java8:lambda中collect接口案例及原理详解,官方文档解读
ice-wee的专栏
11-30 6384
本文简要介绍toList,toMap等会简要介绍,主要是介绍collect的"底层",及如何触类旁通。 lambda偏具体实现：https://blog.csdn.net/wabiaozia/article/details/103324562 lambda偏底层原理：Lambda 底层实现分析 1 案例中使用到的实体类Employee 见java8的lambda中的map...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 319
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 570
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1091
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 132
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 591
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
Java8流与收集器详解：从概念到实践
"本文主要探讨了Java 8引入的流(Stream)的概念以及收集器(Collector)，通过具体的代码示例提供了详细的解释，旨在帮助读者理解和掌握这一新特性，以提升学习和工作效率。" 在Java 8中，流(Stream)是一个全新的概念...
评论 37
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值