java新特性--03-1--Stream---Collectors工具类

已于 2024-06-04 17:23:54 修改
阅读量325 收藏 7
点赞数 3
分类专栏： java基础 文章标签： java windows 开发语言
于 2024-06-04 17:22:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48052161/article/details/139447047
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

1.stream 收集

在这里插入图片描述

Collectors工具类

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

注意区分 Collections工具类

在这里插入图片描述

练习1：查找工资大于6000的员工，结果返回为一个List

   @Test
    public void  test02() {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee(1001, "马化腾", 34, 6000.38));
        list.add(new Employee(1002, "马云", 12, 9876.12));
        list.add(new Employee(1003, "刘强东", 33, 3000.82));
        list.add(new Employee(1004, "雷军", 26, 7657.37));
        list.add(new Employee(1005, "李彦宏", 65, 5555.32));
        list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
        list.add(new Employee(1007, "任正非", 26, 4333.32));
        list.add(new Employee(1008, "扎克伯格", 35, 2500.32));


        List<Employee> employeeList = list.stream().filter(e ->
                e.getSalary() > 6000).collect(Collectors.toList());

        employeeList.forEach(System.out::println);
    }

在这里插入图片描述

练习2：查找年龄小于40的员工，结果返回为一个set

 @Test
    public void test02() {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee(1001, "马化腾", 34, 6000.38));
        list.add(new Employee(1002, "马云", 12, 9876.12));
        list.add(new Employee(1003, "刘强东", 33, 3000.82));
        list.add(new Employee(1004, "雷军", 26, 7657.37));
        list.add(new Employee(1005, "李彦宏", 65, 5555.32));
        list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
        list.add(new Employee(1007, "任正非", 26, 4333.32));
        list.add(new Employee(1008, "扎克伯格", 35, 2500.32));


        Set<Employee> employeeSet = list.stream().filter(employee ->
                employee.getAge() < 40
        ).collect(Collectors.toSet());

        employeeSet.forEach(System.out::println);
    }

在这里插入图片描述

练习2：Collectors.toMap

在这里插入图片描述

package com.cy.month11;


import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class Test05 {
    public static void main(String[] args) {
        List<Employee> list = Arrays.asList(new Employee("1","张三"),
                new Employee("2","李四"),
                new Employee("3","王五"));

        Map<String, String> map = list.stream().collect(Collectors.toMap(Employee::getId, Employee::getName));
        System.out.println(map.toString());
        
    }

    private static class Employee {
        String id;
        String name;

        public Employee(String id, String name) {
            this.id = id;
            this.name = name;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

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

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

(v1, v2) -> v2

在这里插入图片描述

  • (v1, v2) -> v2 表示如果有相同的key,则使用后面的值覆盖key已经有的值。
  • 如果(v1, v2) ->v1, 则不覆盖,保留key已经有的值。

Map相同的key只能有一个。(注意:如果不指定覆盖策略,遇到相同key会抛异常)

案例

    public static void main(String[] args) {
        List<Person> personList =new ArrayList<>();
        personList.add(new Person("于问问","988"));
        personList.add(new Person("苗问问","988"));
        personList.add(new Person("李问问","777"));
        Map<String, String> personMap = personList.stream()
                     .collect(
                          Collectors.toMap(Person::getCode, Person::getName)
                              );
    }

这样会不会有问题?答案是会有问题的。
Map的key值不能重复，现在于问问和苗问问的code号都是988

遇到这种情况转Map时就必须得有取舍了，苗问问和于问问只能留一个，那就留苗问问吧

        Map<String, String> personMap = personList.stream()
            .collect(Collectors.toMap(Person::getCode, Person::getName, (v1, v2) -> v2));

2.Collectors.groupingBy

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

@Data
@AllArgsConstructor
public class Student {

    String name ;

    int  age;

    String clazz ;

    String course ;c

    int  score;


}

1. 基础分组功能 （3种写法一样效果）

  • 说明：基础功能，分组并返回Map容器。将用户自定义的元素作为键，同时将键相同的元素存放在List中作为值。


import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class test {


    public static void main(String[] args) {

        List<Student> students = Stream.of(
                new Student("张三", 16, "高一1班", "语文", 88),
                new Student("李四", 17, "高一2班", "数学", 90),
                new Student("王五", 18, "高一3班", "外语", 100)

        ).collect(Collectors.toList());


        // 方法1 ：将不同课程的学生进行分类
        Map<String, List<Student>> groupByCourse = students.stream().collect(Collectors.groupingBy(Student::getCourse));
        System.out.println(groupByCourse);



        //  方法2 ：上面的方法中容器类型和值类型都是默认指定的，容器类型为：HashMap，值类型为：ArrayList
        Map<String, List<Student>> groupByCourse1 = students.stream().collect(Collectors.groupingBy(Student::getCourse, Collectors.toList()));
        System.out.println(groupByCourse1);


        // 方法3 ： 可以通过下面的方法自定义返回结果、值的类型
        Map<String, List<Student>> groupByCourse2 = students.stream().collect(Collectors.groupingBy(Student::getCourse, HashMap::new, Collectors.toList()));
        System.out.println(groupByCourse2);


    }


}


{数学=[Student(name=李四, age=17, clazz=高一2班, course=数学, score=90)], 语文=[Student(name=张三, age=16, clazz=高一1班, course=语文, score=88)], 外语=[Student(name=王五, age=18, clazz=高一3班, course=外语, score=100)]}
{数学=[Student(name=李四, age=17, clazz=高一2班, course=数学, score=90)], 语文=[Student(name=张三, age=16, clazz=高一1班, course=语文, score=88)], 外语=[Student(name=王五, age=18, clazz=高一3班, course=外语, score=100)]}
{数学=[Student(name=李四, age=17, clazz=高一2班, course=数学, score=90)], 语文=[Student(name=张三, age=16, clazz=高一1班, course=语文, score=88)], 外语=[Student(name=王五, age=18, clazz=高一3班, course=外语, score=100)]}
2.自定义键——字段映射在这里插入图片描述
package com.cy.demo;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class test {


    public static void main(String[] args) {

        List<Student> students = Stream.of(
                new Student("张三", 16, "高一1班", "语文", 88),
                new Student("李四", 17, "高一2班", "数学", 90),
                new Student("王五", 18, "高一3班", "外语", 100)

        ).collect(Collectors.toList());


        // 字段映射 分组显示每个课程的学生信息
        Map<String, List<Student>> filedKey = students.stream().collect(Collectors.groupingBy(Student::getCourse));
        System.out.println(filedKey);

        // 组合字段 分组现实每个班不同课程的学生信息
        Map<String, List<Student>> combineFiledKey = students.stream().collect(Collectors.groupingBy(student -> student.getClazz() + "#" + student.getCourse()));
        System.out.println(combineFiledKey);


    }


}


{数学=[Student(name=李四, age=17, clazz=高一2班, course=数学, score=90)], 
语文=[Student(name=张三, age=16, clazz=高一1班, course=语文, score=88)], 
外语=[Student(name=王五, age=18, clazz=高一3班, course=外语, score=100)]}

{高一2班#数学=[Student(name=李四, age=17, clazz=高一2班, course=数学, score=90)],
 高一1班#语文=[Student(name=张三, age=16, clazz=高一1班, course=语文, score=88)], 
 高一3班#外语=[Student(name=王五, age=18, clazz=高一3班, course=外语, score=100)]}
3.自定义键——范围
package com.cy.demo;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class test {


    public static void main(String[] args) {

        List<Student> students = Stream.of(
                new Student("张三", 16, "高一1班", "语文", 75),
                new Student("李四", 17, "高一2班", "数学", 55),
                new Student("王五", 18, "高一3班", "外语", 100)

        ).collect(Collectors.toList());


        // 根据两级范围 将学生划分及格不及格两类
        Map<Boolean, List<Student>> customRangeKey = students.stream().collect(Collectors.groupingBy(student -> student.getScore() > 60));
        System.out.println(customRangeKey);

        // 根据多级范围 根据学生成绩来评分
        Map<String, List<Student>> customMultiRangeKey = students.stream().collect(Collectors.groupingBy(student -> {
            if (student.getScore() < 60) {
                return "C";
            } else if (student.getScore() < 80) {
                return "B";
            }
            return "A";
        }));

        System.out.println(customMultiRangeKey);

    }


}


{false=[Student(name=李四, age=17, clazz=高一2班, course=数学, score=55)],
 true=[Student(name=张三, age=16, clazz=高一1班, course=语文, score=75), Student(name=王五, age=18, clazz=高一3班, course=外语, score=100)]}

{A=[Student(name=王五, age=18, clazz=高一3班, course=外语, score=100)], 
B=[Student(name=张三, age=16, clazz=高一1班, course=语文, score=75)],
C=[Student(name=李四, age=17, clazz=高一2班, course=数学, score=55)]}

4.计数 求和 平均值

package com.cy.demo;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class test {


    public static void main(String[] args) {

        List<Student> students = Stream.of(
                new Student("张三", 16, "高一1班", "语文", 75),
                new Student("李四", 17, "高一2班", "数学", 55),
                new Student("王五", 18, "高一3班", "外语", 100),
                new Student("赵六", 18, "高一1班", "语文", 88)

        ).collect(Collectors.toList());


        // 计数
        Map<String, Long> groupCount = students.stream()
                .collect(Collectors.groupingBy(Student::getCourse, Collectors.counting()));
        System.out.println(groupCount);

        // 求和
        Map<String, Integer> groupSum = students.stream()
                .collect(Collectors.groupingBy(Student::getCourse, Collectors.summingInt(Student::getScore)));
        System.out.println(groupSum);

        // 增加平均值计算
        Map<String, Double> groupAverage = students.stream()
                .collect(Collectors.groupingBy(Student::getCourse, Collectors.averagingInt(Student::getScore)));
        System.out.println(groupAverage);

    }


}

在这里插入图片描述

3.Function.identity()

1.JDK源码

Java 8允许在接口中加入具体方法。接口中的具体方法有两种，default方法和static方法，identity()就是Function接口的一个静态方法。

  • Function.identity()返回一个输出跟输入一样的Lambda表达式对象，等价于形如t -> t形式的Lambda表达式。

在这里插入图片描述

2.用法

当我们使用 Stream 想要将集合的某一属性（例如手机号）作为 key，对象本身作为 value 时，就可以在 Collectors.toMap() 中配合使用 Function.identity()。

// 查询数据
List<UserInfo> list = userInfoMapper.getList();
// 获取 手机号-UserInfo 映射
Map<String, UserInfo> phoneNumberMap = list.stream().collect(Collectors.toMap(UserInfo::getPhoneNumber(), Function.identity(), (v1, v2) -> v1));

不适用场景

不适用于 mapToInt()、mapToLong()、mapToDouble() 等需要进行拆箱操作的场景。

public static void main(String[] args) {
	List<Integer> list = Arrays.asList(1, 2, 3);
	int[] array = list.stream().mapToInt(Function.identity()).toArray();
	System.out.println(array.length);
}

在这里插入图片描述

3.案例

案例1

    public static void main(String[] args) {
        Stream<String> stream = Stream.of("This", "is", "a", "test");
        Map<String, Integer> map = stream.collect(Collectors.toMap(Function.identity(), String::length));
        System.out.println(map);

    }

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

案例2

private static class Employee {
        String id;
        String  age;
        String name;

        public Employee(String id, String age, String name) {
            this.id = id;
            this.name = name;
            this.age = age;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

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

        public String getAge() {
            return age;
        }

        public void setAge(String age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Employee{" +
                    "id='" + id + '\'' +
                    ", age='" + age + '\'' +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        List<Employee> list = Arrays.asList(new Employee("1","18","张三"),
                new Employee("2","25","李四"),
                new Employee("3","25","王五"));

        Map<String, String> map1 = list.stream().collect(Collectors.toMap(Employee::getId, Employee::getName,(v1, v2) -> v2) );
        System.out.println(map1.toString());

        Map<String, Employee> map2 = list.stream().collect(Collectors.toMap(Employee::getId, Function.identity()));
        System.out.println(map2.toString());
    }

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

对比 Collectors.groupingBy

  • Function.identity() 返回是对象本身 Map<String, Employee>
  • Collectors.groupingBy 返回的是 Map<String, List< Employee>>
    public static void main(String[] args) {
        List<Employee> list = Arrays.asList(new Employee("1","18","张三"),
                new Employee("2","25","李四"),
                new Employee("3","25","王五"));

        Map<String, String> map1 = list.stream().collect(Collectors.toMap(Employee::getId, Employee::getName,(v1, v2) -> v2) );
        System.out.println(map1.toString());

        Map<String, Employee> map2 = list.stream().collect(Collectors.toMap(Employee::getId, Function.identity()));
        System.out.println(map2.toString());

        Map<String, List<Employee>> map3 = list.stream().collect(Collectors.groupingBy(Employee::getId));
        System.out.println(map3.toString());

        Map<String, List<Employee>> map4 = list.stream().collect(Collectors.groupingBy(Employee::getAge));
        System.out.println(map4.toString());

    }

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

在这里插入图片描述

在这里插入图片描述

知行合一。。。
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8StreamAPI实战：从零开始实现一个工具类
禅与计算机程序设计艺术
07-30 1104
首先，我想先简单介绍一下我的个人情况，因为我是一名技术专家。我的主要工作方向是Java后台开发，主要职责是架构设计、系统开发、模块开发、框架搭建等工作。同时，我也是一个开源项目Committer，我为一些优秀的开源项目做贡献。例如，Spring Boot、dubbo、spring cloud等。这些开源项目都是非常优秀的，因此，我喜欢探索它们背后的设计理念和编程技巧。
java8新特性-最新
12-18
在Java 8中，最重要的两个新特性无疑是Lambda表达式和Stream API。这两个特性都与函数式编程思想密切相关，让Java开发者能够更加灵活地处理数据。 ### Lambda表达式 Lambda表达式是Java 8中最显著的新特性之一，它...
Java8 Stream流工具类(CollectionStreamUtil)
XiaoZhongYu的博客
04-17 693
Java8 Stream流工具类
java Stream操作相关工具类
weixin_44215249的博客
12-24 400
import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Set; import java.util.function.Function; import java.util.function.Predicate; import
java8之工具类Stream
chenyang1010的博客
03-30 291
Stream的出现是为了让java支持函数式编程，从而使得写出的代码更加的紧凑可读。 public class MyStream { //stream的中间处理函数和终极处理函数 //stream的中间处理函数会继续返回stream //stream的终极处理函数会处理集合里面的数据，返回最终的结果 @Test public void test1() { final Collect...
Java Stream工具类操作使用
weixin_59181205的博客
11-24 1083
StreamUtils改造
jdk1.8-32位.zip
04-30
JDK 1.8，也称为Java 8，是Oracle公司发布的一个重要版本，它引入了许多新特性和改进。以下是这个版本的一些关键知识点： 1. **Lambda表达式**：这是Java 8最大的特性之一，它允许以更简洁的方式编写匿名函数。...
Java-IO流/Stream流总结
07-12
- **Collectors**：`Collectors`工具类提供了许多静态方法，用于生成收集器，如`toList()`, `toSet()`, `joining()`等，用于将Stream转换为其他数据结构。 6. **资源文件Properties** - **Properties**类用于处理...
jdk-11.0.7_windows-x64_bin.zip
04-20
5. **并行流收集器 (ParallelStream Collectors)**：在Java 11中，Stream API的并行收集器得到了改进，可以更好地利用多核处理器资源，提高程序性能。 6. **改进的JNI签名 (VarHandle)**：提供了VarHandle类，用于...
java8stream源码-java8:Java8特性
06-04
- `collect(Collector c)`：将流元素收集到一个容器中，可以使用`Collectors`工具类提供的各种收集器，如`toList()`, `toSet()`, `joining()`, `summarizingInt()`等。 - `findFirst()`：找到并返回流的第一个元素...
JAVA8之工具类Stream
Zn昕的博客
07-17 4142
                                 JAVA8之工具类Stream 一.    概述         在jdk1.8中引入的新的对集合中数据的处理的--Stream流.该工具类常常被我们用来对集合中数据的筛选,处理等等,使用流可以大大的减少我们的代码量,也是我们的代码逻辑性更强,更容易明白每一步是在做什么. 二.    特性         1.    流不会...
JAVA工具篇--JAVA8-Stream
拽着尾巴的鱼儿的博客
01-18 722
流是java API中的新的成员，它可以让你用声明式的方式处理集合，简单点说，可以看成遍历数据的一个高级点的迭代器，也可以看做一个工厂，数据处理的工厂，当然，流还天然的支持并行操作。也就是说流中的元素遍历到了第n个过后，后面的元素就不在进行遍历了。同样其中将stream() 替换为parallelStream() 可以让其进行并发处理以提高效率。其中将stream() 替换为parallelStream() 可以让其进行并发处理以提高效率。// 给年纪大于30岁的人，薪水提升1.5倍，并输出结果。
JAVA8必看～～效率工具类Stream底层原理超详细傻瓜式解析
zdh652306的博客
02-12 1450
stream源码保姆式解析
Stream工具类
weixin_43689953的博客
12-04 356
https://mp.weixin.qq.com/s?__biz=MzU4MDUyMDQyNQ==&mid=2247489747&idx=2&sn=5c5aacef6d3344fc43202ede97adba2b&chksm=fd54c855ca234143d8387150ce033268ab21cadfbd16f682bb15318e250015db162320faeb62&mpshare=1&scene=1&srcid=1124WNSGnKu2Ce
Stream工具类1
weixin_44831041的博客
08-31 283
stream工具
`ObjectInputStream`和`ObjectOutputStream`是Java中用于对象序列化和反序列化的工具类，它们可以方便地实现对象数据的读写
最新发布
BLOG域名:programb.blog.csdn.net
02-28 541
在Java中，对象序列化是一种将内存中的对象状态转换为字节流的过程，以便将其存储到文件或通过网络发送到另一个Java虚拟机（JVM）。要使用它，需要首先实例化一个ObjectOutputStream对象，然后通过该对象的writeObject()方法将对象写入输出流。在上面的代码中，我们从名为"object.ser"的文件中读取了一个序列化的对象，并将其反序列化为一个MyClass类型的对象。在上面的代码中，我们将一个MyClass类型的对象序列化并写入到了名为"object.ser"的文件中。
java树结构stream工具类
zsj777的专栏
03-16 610
菜单实体类 package com.example.demo.entity; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; import java.util.List; @Data @Builder @AllArgsConstructor @NoArgsConstructor public class Menu { /
Java 自定义StreamUtils工具类，生产力max，后端程序员必看。
weixin_59181205的博客
08-14 858
mybatis-plus，StreamUtils工具类，快捷方便操作java Stream流。
工具类3：java的流
weixin_43930865的博客
04-05 202
java的流 流在Java中是指计算中流动的缓冲区。 从外部设备流向中央处理器的数据流成为“输入流”，反之成为“输出流”。 1：流的分类 流------》接口-----》实现类------》缓冲流 **只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流。** 1.1：字符流和字节流的主要区别 字节流：读取的时候，读到一...
mybatis-plus树形结构查询
05-26
MyBatis-Plus是一个MyBatis的增强工具，提供了许多实用的功能，其中就包括树形结构查询的支持。 在使用MyBatis-Plus进行树形结构查询时，需要使用到两个重要的注解： - @TableName：用于指定实体类对应的数据表名...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值