JAVA 8 Lambda处理List＜Object＞集合

最新推荐文章于 2024-05-20 17:41:15 发布
最新推荐文章于 2024-05-20 17:41:15 发布
阅读量1.9k 收藏 9
点赞数 2
分类专栏： Java 8 Java 文章标签： spring java list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41525524/article/details/121471650
版权
Java 同时被 2 个专栏收录
25 篇文章 0 订阅
订阅专栏
Java 8
6 篇文章 0 订阅
订阅专栏

目录

1.创建Student对象

Student.java

@Data
public class Student {
    //学号
    private Integer id;
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private String gender;
    //地址
    private String address;

    //有参构造函数
    public Student(Integer id, String name, Integer age, String gender, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

    /**
     * @description TODO 控制台输出结果集
     * @param studentList Student对象集合数据信息
     * @return void
     */
    public static void printlnStudent(List<Student> studentList) {
        System.out.println("学 号      姓 名      年 龄      性 别      地 址");
        for (int i=0; i<studentList.size(); i++){
            System.out.println(studentList.get(i).getId()+"    "+studentList.get(i).getName()+"       "+studentList.get(i).getAge()+"          "+studentList.get(i).getGender()+"       "+studentList.get(i).getAddress());
        }
        System.out.println();
    }

}

GenderInfo.java

/**
 * @Description: 性别
 * @Auther: Wangtianming
 * @Date: 2021/11/23 10:06
 */
@Data
public class GenderInfo {

    private String genderId;

    private String genderName;

    //有参构造函数
    public GenderInfo(String genderId, String genderName) {
        this.genderId = genderId;
        this.genderName = genderName;
    }


}

2.集合对象添加数据

/**
     * @param
     * @return List<Student>
     * @description TODO 获取Student对象集合数据信息
     */
    public static List<Student> getStudentData() {
        //存放Student对象集合
        List<Student> studentList = new ArrayList<Student>();
        //使用有参构造给对象赋值
        Student student1 = new Student(2021001, "张三", 24, "1", "北京");
        Student student2 = new Student(2021002, "李四", 25, "1", "北京");
        Student student3 = new Student(2021003, "王五", 20, "1", "上海");
        Student student4 = new Student(2021004, "赵六", 20, "2", "天津");
        Student student5 = new Student(2021005, "邹七", 22, "2", "天津");
        //将对象添加到List集合中
        studentList.add(student1);
        studentList.add(student2);
        studentList.add(student3);
        studentList.add(student4);
        studentList.add(student5);
        return studentList;
    }

3.分组

List里面的对象元素，以某个属性来分组，例如，以Address(地址)分组，将Address相同的放在一起。

/**
     * @description TODO 分组
     *                   List里面的对象元素，以某个属性来分组，例如，以Address(地址)分组，将Address相同的放在一起
     * @param
     * @return void
     */
    public static void groupBy() {
        List<Student> studentList = getStudentData();
        //List 以address分组  Map<String,List<Student>>
        Map<String, List<Student>> groupBy = studentList.stream().collect(Collectors.groupingBy(Student::getAddress));
        System.err.println(groupBy);
    }

输出结果

{上海=[Student(id=2021003, name=王五, age=20, gender=男, address=上海)], 
 天津=[Student(id=2021004, name=赵六, age=20, gender=女, address=天津), Student(id=2021005, name=邹七, age=22, gender=女, address=天津)], 
 北京=[Student(id=2021001, name=张三, age=24, gender=男, address=北京), Student(id=2021002, name=李四, age=25, gender=男, address=北京)]}

4.list转map

需要注意的是：

  1. toMap 如果集合对象有重复的key，会报错Duplicate key …
  2. student1,student2的Address都为北京，可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
/**
     * @description TODO List 转 Map
     *                  List -> Map
     * @param
     * @return void
     */
    public static void listConversionMap() {
        List<Student> studentList = getStudentData();
        /**
         * List -> Map
         * 需要注意的是：
         *  toMap 如果集合对象有重复的key，会报错Duplicate key ....
         *  student1,student2 的Address都为 北京。
         *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
         */
        Map<String, Student> studentMap = studentList.stream().collect(Collectors.toMap(Student::getAddress, a -> a,(k1,k2)->k1));
        System.err.println(studentMap);
    }

输出结果：

{上海=Student(id=2021003, name=王五, age=20, gender=男, address=上海), 
 天津=Student(id=2021004, name=赵六, age=20, gender=女, address=天津), 
 北京=Student(id=2021001, name=张三, age=24, gender=男, address=北京)}

5.去重

按照 Address(居住地) 去重
.filter(info -> StringUtils.isNotBlank(info.getAddress()))判断是否为null，如果不为null，则不需要加。

 /**
     * @description TODO 去重
     * @param
     * @return void
     */
    public static void distinctList() {
        List<Student> studentList = getStudentData();

        System.err.println("---------------------去重前-------------------------");
        Student.printlnStudent(studentList);

        // 按照 Address(居住地) 去重
        studentList = studentList.stream().filter(info -> StringUtils.isNotBlank(info.getAddress()))
                .collect(Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Student::getAddress))),
                        ArrayList::new));
        System.err.println("---------------------去重后-------------------------");
        Student.printlnStudent(studentList);//控制台输出
    }

输出结果：
在这里插入图片描述

6.过滤筛选

筛选年龄大于等于24岁的学生。

/**
     * @description TODO 过滤筛选
     * @param
     * @return void
     */
    public static void filterList() {
        List<Student> studentList = getStudentData();

        System.err.println("---------------------过滤筛选前-------------------------");
        Student.printlnStudent(studentList);

        // 筛选年龄大于等于24岁的学生
        studentList = studentList.stream().filter(item -> item.getAge() >= 24).collect(Collectors.toList());

        System.err.println("---------------------过滤筛选后-------------------------");
        Student.printlnStudent(studentList);  //控制台输出

    }

输出结果：
在这里插入图片描述

7.排序 注意：(排序字段可以为 null， null不会导致排序失败)

  1. 按照年龄从大到小排序。
  2. 按照年龄从小到大排序。
  3. 先按照年龄从小到大排序排序，再按照id从大到小排序
/**
     * @description TODO 排序  注意：(排序字段可以为 null， null不会导致排序失败)
     * @param
     * @return void
     */
    public static void sortList() {
        List<Student> studentList = getStudentData();


        // 按照年龄从大到小排序
        // 方式一
        studentList.sort((stu1, stu2)
                -> stu1.getAge() == null ? 1 : (stu2.getAge() == null ? -1 : stu2.getAge().compareTo(stu1.getAge())));

        System.out.println("---------------------按照年龄从大到小排序后 方式一-------------------------");
        Student.printlnStudent(studentList);  //控制台输出


        // 方式二
        studentList.sort(Comparator.comparing(Student::getAge, (stu1, stu2)
                -> stu1 == null ? 1 : (stu2 == null ? -1 : stu2.compareTo(stu1))));

        System.out.println("---------------------按照年龄从大到小排序后 方式二-------------------------");
        Student.printlnStudent(studentList);  //控制台输出




        // 按照年龄从小到大排序
        // 方式一
        studentList.sort((stu1, stu2)
                -> stu2.getAge() == null ? 1 : (stu1.getAge() == null ? -1 : stu1.getAge().compareTo(stu2.getAge())));

        System.out.println("---------------------按照年龄从小到大排序后 方式一-------------------------");
        Student.printlnStudent(studentList); //控制台输出

        // 方式二
        studentList.sort(Comparator.comparing(Student::getAge, (stu1, stu2)
                -> stu2 == null ? 1 : (stu1 == null ? -1 : stu1.compareTo(stu2))));

        System.out.println("---------------------按照年龄从小到大排序后 方式二-------------------------");
        Student.printlnStudent(studentList); //控制台输出




        // 先按照年龄从小到大排序排序，再按照id从大到小排序
        studentList.sort(Comparator.comparing(Student::getAge, (stu1, stu2)
                -> stu1 == null ? 1 : (stu2 == null ? -1 : stu1.compareTo(stu2))).thenComparing((stu1, stu2)
                -> stu1.getId() == null ? 1 : (stu2.getId() == null ? -1 : stu2.getId().compareTo(stu1.getId()))));
        System.out.println("---------------------先按照年龄从小到大排序排序，再按照id从大到小排序后-------------------------");
        Student.printlnStudent(studentList); //控制台输出
    }

输出结果：
在这里插入图片描述

8.删除

    /**
     * @description TODO Iterator删除list
     * @param
     * @return void
     */
    public static void removeList() {
        List<Student> studentList = getStudentData();
        Iterator<Student> iterator = studentList.iterator();
        while (iterator.hasNext()){
            Student student = iterator.next();
            if("王五".equals(student.getName())){
                iterator.remove();
            }
        }
        studentList.forEach(System.out::println);
    }

输出结果：

Student(id=2021001, name=张三, age=24, gender=男, address=北京)
Student(id=2021002, name=李四, age=25, gender=男, address=北京)
Student(id=2021004, name=赵六, age=20, gender=女, address=天津)
Student(id=2021005, name=邹七, age=22, gender=女, address=天津)

9.获取list前两条数据

    /**
     * @description TODO 获取list前两条数据
     * @param
     * @return void
     */
    public static void subList() {
        List<Student> studentList = getStudentData();
        System.out.println("---------------------截取前-------------------------");
        studentList.forEach(System.out::println);

        System.out.println("---------------------截取后-------------------------");
        List<Student> studentInfo = studentList.subList(0,2);
        studentInfo.forEach(System.out::println);
    }

输出结果：

---------------------截取前-------------------------
Student(id=2021001, name=张三, age=24, gender=男, address=北京)
Student(id=2021002, name=李四, age=25, gender=男, address=北京)
Student(id=2021003, name=王五, age=20, gender=男, address=上海)
Student(id=2021004, name=赵六, age=20, gender=女, address=天津)
Student(id=2021005, name=邹七, age=22, gender=女, address=天津)
---------------------截取后-------------------------
Student(id=2021001, name=张三, age=24, gender=男, address=北京)
Student(id=2021002, name=李四, age=25, gender=男, address=北京)

10.替换 （ListA 中的gender，与 ListB 中的genderId相匹配，并且赋值给ListB中的genderName）

    /**
     * @param
     * @return void
     * @description TODO 替换 List<A> 中的gender，与 List<B> 中的genderId相匹配，并且赋值给List<B>中的genderName
     */
    public static void replaceList() {
        List<Student> studentList = getStudentData();
        List<GenderInfo> sexInfoList = new ArrayList<>();
        GenderInfo sexInfo1 = new GenderInfo("1", "男");
        GenderInfo sexInfo2 = new GenderInfo("2", "女");
        sexInfoList.add(sexInfo1);
        sexInfoList.add(sexInfo2);
        System.out.println("---------------------替换前-------------------------");
        studentList.forEach(System.out::println);

        studentList.stream().map(student -> sexInfoList.stream().filter(sexInfo -> student.getGender().equals(sexInfo.getGenderId())).findFirst().map(sexInfo -> {
            student.setGender(sexInfo.getGenderName());
            return student;
        }).orElse(null)).collect(Collectors.toList());
        System.out.println("---------------------替换后-------------------------");
        studentList.forEach(System.out::println);
    }

输出结果：

---------------------替换前-------------------------
Student(id=2021001, name=张三, age=24, gender=1, address=北京)
Student(id=2021002, name=李四, age=25, gender=1, address=北京)
Student(id=2021003, name=王五, age=20, gender=1, address=上海)
Student(id=2021004, name=赵六, age=20, gender=2, address=天津)
Student(id=2021005, name=邹七, age=22, gender=2, address=天津)
---------------------替换后-------------------------
Student(id=2021001, name=张三, age=24, gender=男, address=北京)
Student(id=2021002, name=李四, age=25, gender=男, address=北京)
Student(id=2021003, name=王五, age=20, gender=男, address=上海)
Student(id=2021004, name=赵六, age=20, gender=女, address=天津)
Student(id=2021005, name=邹七, age=22, gender=女, address=天津)

11. 获取list某个字段组装新list

 List<Student> studentList = getStudentData();
 List<Integer> studentIdList = studentList.stream().map(a -> a.getId()).collect(Collectors.toList());
 
studentIdList.forEach(System.out::println);

输出结果：

2021001
2021002
2021003
2021004
2021005

12. list求最小与最大，使用min max方法

//最小
Integer minAge = studentList.stream().map(Student::getAge).min(Integer::compareTo).get();
//最大
Integer maxAge = studentList.stream().map(Student::getAge).max(Integer::compareTo).get();

System.out.println("最大："+ minAge);
System.out.println("最小："+ maxAge);

输出结果：

最大：20
最小：25

13.List<对象> 列转行

 TeacherInfo a0 = new TeacherInfo("1001","a");
 TeacherInfo a1 = new TeacherInfo("1001","b");
 TeacherInfo a2 = new TeacherInfo("1002","c");
 TeacherInfo a3 = new TeacherInfo("1002","d");
 List<TeacherInfo> list = new ArrayList<>();
 list.add(a0);
 list.add(a1);
 list.add(a2);
 list.add(a3);
 Map<String,List<TeacherInfo>> mapListInfo = list.stream().collect(Collectors.groupingBy(TeacherInfo::getGenderId));
 Map<String, Optional<String>> map = mapListInfo.keySet().stream().collect(Collectors.toMap(a -> a, b -> mapListInfo.get(b).stream().map(TeacherInfo :: getGenderName).reduce(( c ,d ) ->c +","+ d)));

 System.out.println("原来数据===========");
 System.out.println(list.toString());
 System.out.println("转换后数据===========");
 for (String key : map.keySet ()) {
     String value = map.get (key).get ();
     System.out.println("key="+ key +" value=" + value);
 }

输出结果：

原来数据===========
[TeacherInfo(genderId=1001, genderName=a), TeacherInfo(genderId=1001, genderName=b), TeacherInfo(genderId=1002, genderName=c), TeacherInfo(genderId=1002, genderName=d)]
转换后数据===========
key=1002 value=c,d
key=1001 value=a,b
会飞的天明
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8中的 Lambda表达式教程
08-31
Java 8 中的 Lambda 表达式是一种强大的编程特性，它...通过这些特性，Java 8的Lambda表达式让代码更加简洁、易读，特别是在处理高阶函数和函数式编程场景时。理解和熟练使用Lambda表达式是提升Java 8开发效率的关键。
java8传函数方法图文详解
08-26
Java 8 引入了一项重大特性，即函数式编程，它允许我们将函数作为参数传递，这在处理集合和执行高阶操作时尤其有用。在Java 8中，这一功能主要通过函数接口（Functional Interface）来实现，这些接口只有一个抽象...
List<Object[]> 的用法
solo.du
09-22 3583
@SuppressWarnings("unchecked") public List&lt;Object[]&gt; getContentListByAppTitle(String username) { username = username.trim(); List&lt;Object[]&gt; lists = getJpaTemplate() .find("sele...
List＜Object＞强制类型转换为指定类型的List集合
热门推荐
weixin_41979002的博客
01-07 1万+
已修正 一、案例1 将List<Object>强制类型转换为指定类型的List集合。 先看下面一个例子： public class Test { public static void main(String[] args) { List<Object> list = getList(); //List<User> userList = (List<User>)list;//编译失败 //方式一： for (O
Java-两个集合取交集（4种方式）
最新发布
努力搬砖，顶峰相见
05-20 1110
开发难免需要对集合进行操作，例如对两个集合取交集也是常见操作。下面就列举了几种对两个集合取交集的方法。
Lambda表达式-实际应该用-List过滤指定元素
jianwen_tian的博客
12-20 2831
import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; /** * @ClassName Demo * @Description Lambda表达式--List过滤指定元素 * @author TianJianWen * @data 2019年11月14日下午3:27:2...
MybatisPlus使用详解
拱卒的博客
11-25 4195
参考内容 MybatiesPlus 官网 SQL基本语法 Mybaties3官网 mybatis-plus快速入门并使用 mybatis-plus中wrapper的用法（详细） 搭建工程继承测试 搭建工程 集成测试 插件介绍 项目基本文件我是用该插件生成的 方法上Alt + Enter idea 连接数据 快速生成 Mybaties 的简单案例 mapper // 简单实现两个接口 @Mapper public interface GoodsMapper extends BaseMapper<G
【Java中将一个List根据Object中的一个key进行分组】
JavaxiaoxiaoBai的博客
01-06 357
Java将一个List 根据Object中的一个key进行分组
Java中List集合对象去重及按属性去重的8种方法
09-08
【Java中List集合对象去重及按属性去重的8种方法】 在Java编程中，当我们处理包含重复元素的List时，有时需要去除其中的重复项。以下文章将详细介绍8种针对List集合对象去重的方法，包括基于对象整体以及按特定属性...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
总的来说，Java 8的Lambda表达式为开发者提供了更优雅、更简洁的方式来处理集合数据，简化了代码，并引入了函数式编程的思维方式。通过熟练掌握Lambda表达式，你可以编写出更高效、更易于理解和维护的Java代码。
Java集合概述与实例分析
10-26
3. Lambda表达式：Java 8引入的新特性，可以更简洁地遍历集合。例如，使用`collection.forEach(action)`，其中action是一个Lambda表达式，定义了对每个元素的操作。 通过实例分析，我们可以更好地理解这些概念。...
记List＜Object＞接受其他泛型入参报错及List、 List＜Object＞、 List＜?＞三者的区别
weixin_43869703的博客
07-17 4874
1.问题 这是我自定义的一个数据传输模型，使用List < Object>作为入参将结果返回到前台 @Data @AllArgsConstructor @NoArgsConstructor @Accessors(chain = true) @ApiModel(description = "自定义返回数据类型") public class SimpleResponseBody { @ApiModelProperty(name = "status",value = "状态码") pr
java修改其他对象的list_Java通过lambda表达式修改List对象中的属性。
weixin_35273106的博客
02-25 3467
public class testDemo {public List objectTest(){List deployVOList = new ArrayList<>();for(int i=0; i<5; i++){DeployVO deployVO = new DeployVO();deployVO.setDeployId(“1”+i);deployVO.setDeployn...
mybatis-plus listObjs的使用|lambda function错误
elsostal的博客
12-08 3753
这个方法要怎么用有谁知道 <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper); 我要写一个方法，根据carVo的carNumber查询car_dept表，这个表里一个car_number会有多条数据，我需要的就是多条数据里的一个字段（dept_id）字段组合成的list，我写的方法如下： public R update(@Valid @Reques
Java_缓冲区&&IO流&&字符编码&&Lambda 表达式
qq_43408367的博客
09-19 377
1. 按照读写数据的基本单位不同，分为 字节流 和 字符流。 1. 其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的文件。 2. 其中字符流主要指以字符(2个字节)为单位进行数据读写的流，只能读写文本文件。 2. 按照读写数据的方向不同，分为 输入流 和 输出流（站在程序的角度）。 1. 其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文件。 2. 其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。 3. 按照流的角色不同分为节点流和处理流。 1. 其中节点流
实验七 寻址方式在结构化数据访问中的应用
_Co1a
11-11 1472
下面的程序中，已经定义好了这些数据 ;实验七 寻址方式在结构化数据访问中的应用 ;编程 将data段中的数据 按照如下格式写到table段中，并计算21年中的人均收入（取整） ;结果也按照下面的格式保存在table段中 assume cs:code,ds:data,ss:stack data segment db '1975','1976','1977','1978','1979','1980','1981','1982','1983' db '1984','1985','1986','19.
lambda查询某一行某列数据（id为例）tx
速冻的博客
07-08 1973
level = Convert.ToInt32( equipmentAllLevelSetModel.FirstOrDefault(m => m.Id == gameId).Id),
【MyBatis-Plus】详解Wrappers.＜T＞ lambdaQuery()以及常用过滤方法
maple05的博客
09-12 1万+
Wrappers. lambdaQuery() 是 MyBatis-Plus 中用于创建 LambdaQueryWrapper 对象的方法，它用于构建 SQL 查询条件的起始点。LambdaQueryWrapper 是一种类型安全的查询条件构建方式，通过 lambda 表达式可以更加直观地定义查询条件。
Mybatis-Plus中方法listObjs获取的集合对象object转换为指定对象的集合的解决方法
Zhangss777的博客
05-15 8437
Springboot-MybatisPlus中将Object对象集合转换为指定对象集合的方法
java中 从list<Object>中 获取对象的id集合 返回List<Long> objectId
03-31
可以使用Java8的Stream和Lambda表达式来实现： ``` List<Object> list = new ArrayList<>(); // 假设list中已经有对象 List<Long> objectIdList = list.stream() .map(obj -> obj.getId()) // 假设对象有一个getId()方法用于获取id .collect(Collectors.toList()); ``` 也可以使用普通的for循环来实现： ``` List<Object> list = new ArrayList<>(); // 假设list中已经有对象 List<Long> objectIdList = new ArrayList<>(); for (Object obj : list) { objectIdList.add(obj.getId()); // 假设对象有一个getId()方法用于获取id } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值