根据对象属性名进行List集合排序

最新推荐文章于 2023-06-08 10:09:04 发布
最新推荐文章于 2023-06-08 10:09:04 发布
阅读量394 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31864653/article/details/101286531
版权
根据对象属性名进行List集合排序

功能描述：
非数据实体VO需要进行排序分页

前置条件：
1.使用java8；
2.使用Spring框架；
3.排序字段实现Comparable接口。

参数描述：
sort ：排序字段；
mode：升序或降序；
page：当前页；
limit：限制条数。

代码展示：


import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Field;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * List集合排序分页
 *
 * @author tuojinhui
 * @date 2019-09-11
 */
public class SortPageUtils {

    /**
     * List 集合排序
     * --data sort mode有一个为空就返回原数据
     * --sort属性不存在返回原数据
     * --mode非asc或desc返回原数据
     * --排序属性字段返回类型不与case匹配返回原数据
     *
     * @param data 排序前的集合数据
     * @param sort 排序属性字段 propName
     * @param mode 升序降序字符 asc|desc
     * @return 排序后的集合数据
     */
    public static <T> List<T> sort(List<T> data, String sort, String mode) {
        if (StringUtils.isNotBlank(sort) && StringUtils.isNotBlank(mode) && !CollectionUtils.isEmpty(data)) {
            Class<?> fieldType = getFieldType(data.get(0).getClass(), sort);
            if (fieldType == null) {
                return data;
            }
            if ("asc".equalsIgnoreCase(mode)) {
                switch (fieldType.getName()) {
                    case "java.lang.Byte":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Byte) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.lang.Short":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Short) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.lang.Integer":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Integer) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.lang.Long":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Long) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.lang.Float":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Float) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.lang.Double":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Double) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.lang.Boolean":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Boolean) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.lang.Character":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Character) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "byte":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Byte) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "short":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Short) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "int":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Integer) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "long":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Long) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "float":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Float) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "double":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Double) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "boolean":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Boolean) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "char":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Character) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.lang.String":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.String) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.util.Date":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.util.Date) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.math.BigDecimal":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.math.BigDecimal) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.time.LocalDate":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.time.LocalDate) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.time.LocalTime":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.time.LocalTime) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    case "java.time.LocalDateTime":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.time.LocalDateTime) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.naturalOrder()))).collect(Collectors.toList());
                    default:
                        return data;
                }
            } else if ("desc".equalsIgnoreCase(mode)) {
                switch (fieldType.getName()) {
                    case "java.lang.Byte":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Byte) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.lang.Short":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Short) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.lang.Integer":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Integer) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.lang.Long":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Long) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.lang.Float":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Float) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.lang.Double":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Double) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.lang.Boolean":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Boolean) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.lang.Character":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Character) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "byte":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Byte) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "short":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Short) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "int":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Integer) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "long":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Long) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "float":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Float) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "double":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Double) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "boolean":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Boolean) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "char":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.Character) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.lang.String":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.lang.String) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.util.Date":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.util.Date) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.math.BigDecimal":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.math.BigDecimal) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.time.LocalDate":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.time.LocalDate) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.time.LocalTime":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.time.LocalTime) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    case "java.time.LocalDateTime":
                        return data.stream().sorted(Comparator.comparing((T obj) -> ((java.time.LocalDateTime) getFieldValue(obj, sort, fieldType)), Comparator.nullsLast(Comparator.reverseOrder()))).collect(Collectors.toList());
                    default:
                        return data;
                }
            }
        }
        return data;
    }

    /**
     * List 集合分页
     * data page limit有一个为空就返回原数据
     *
     * @param data  分页前的集合数据
     * @param page  当前页码
     * @param limit 限制条数
     * @return 分页后的集合数据
     */
    public static <T> List<T> page(List<T> data, Integer page, Integer limit) {
        if (!ObjectUtils.isEmpty(page) && !ObjectUtils.isEmpty(limit) && !ObjectUtils.isEmpty(data)) {
            return data.stream()
                    .skip((page - 1) * limit)
                    .limit(limit)
                    .collect(Collectors.toList());
        }
        return data;
    }


    /**
     * List 集合排序分页
     */
    public static <T> List<T> sortPage(List<T> data, Integer page, Integer limit, String sort, String mode) {
        return page(sort(data, sort, mode), page, limit);
    }

    /**
     * 根据属性名 获取字段类型
     *
     * @param clazz Class
     * @param sort  属性名
     * @return 属性类型
     */
    private static <T> Class<?> getFieldType(Class<T> clazz, String sort) {
        if (Stream.of(clazz.getDeclaredFields())
                .filter(field -> field.getName().equals(sort))
                .count() != 1) {
            return null;
        }
        Field targetField = org.springframework.util.ReflectionUtils.findField(clazz, sort);
        org.springframework.util.ReflectionUtils.makeAccessible(targetField);
        return targetField.getType();
    }

    /**
     * 根据属性名、字段类型 获取字段值
     *
     * @param obj  对象
     * @param sort 属性名
     * @param type 属性类型
     * @return 对象为Object的字段值
     */
    private static <T> Object getFieldValue(T obj, String sort, Class<?> type) {
        if (Stream.of(obj.getClass().getDeclaredFields())
                .filter(field -> field.getName().equals(sort))
                .filter(field -> field.getType() == type)
                .count() != 1) {
            return null;
        }
        Field targetField = org.springframework.util.ReflectionUtils.findField(obj.getClass(), sort, type);
        org.springframework.util.ReflectionUtils.makeAccessible(targetField);
        return ReflectionUtils.getField(targetField, obj);
    }

}
fengzi-fengzi
关注
List集合对象中按照不同属性大小排序的实例
08-31
在对List集合对象排序时，我们可以使用Collections.sort()方法，该方法可以根据不同的比较器对List集合对象进行排序。在本例中，我们使用匿名内部类实现Comparator接口，并重写compare方法，以便根据Person对象的...
java list集合排序按某一属性排序操作
08-24
Java List 集合排序按某一属性排序操作 Java 集合框架中提供了多种排序方法，今天我们将介绍如何对 Java List 集合进行排序，特别是按照某一属性进行排序操作。 Java List 集合排序 Java 的 List 集合提供了多种...
【Java】集合对象按照指定属性排序（比如姓名拼音排序）
白茶
07-09 2535
最近项目里需要对集合中的对象按照name属性排序，要求name属性按照字母排序后，返回集合结果，下面是实现方式： 首先要实现排序的对象要实现Comparable类，重写该类的compareTo方法，方法里写明要比较的属性，代码如下： ``` package com.longcloud.oapm.portal.experience.vo; import javax.persistence.Col...
如何根据对象的属性，对集合（list / set）中的对象进行排序
11-06 289
如何根据对象的属性，对集合（list / set）中的对象进行排序 一：针对list 通过java.util.Collections的sort方法，有2个参数，第一个参数是list对象，第二个参数是new Comparator<...
对象按照姓名进行排序
qq_32431191的博客
11-07 919
var arry=[ {name:"张三"，age：19}， {name:"李四"，age：23}， {name:"赵武"，age：16}， ] arry.sort(function(a,b){ return a.name.localeCompare(b.name) })
按照name给list的对象排序
qq_43185463的博客
08-31 271
【代码】按照name给list的对象排序。
List集合根据对象某些属性进行排序
zzxuewuzhijing的博客
06-29 426
public class Test {    public static void main(String[] args) {        List&lt;Student&gt; list = new ArrayList&lt;Student&gt;();        //创建3个学生对象，年龄分别是20、19、21，并将他们依次放入List中        Student s1 = new ...
Java中List集合对象去重及按属性去重的8种方法
09-08
以下文章将详细介绍8种针对List集合对象去重的方法，包括基于对象整体以及按特定属性进行去重。 ### 一、对象整体去重 #### 1. 使用Set（HashSet） 这是最基础的方法，通过将List转换为Set，由于Set不允许重复...
根据某个属性对List中的所有对象分组，该属性值相同的对象分到一个组
12-21
本问题中提到的情况就是如何根据对象的一个属性值对List中的对象进行分组，以便每个组包含具有相同属性值的对象。这种操作在处理集合数据时非常常见，例如在报表生成、数据分析或数据显示优化等场景。 首先，这个...
java根据List内对象的属性排序方法
08-28
"java根据List内对象的属性排序方法" java根据List内对象的属性排序方法是java编程语言中的一种常见且重要的操作。排序是指将一个或多个对象按照某种规则或顺序排列的过程。在java中，List是一个常用的数据结构，...
java list集合按名称排序，再按年龄排序，最后按工资排序。
越努力越有钱的博客
06-15 8667
public static void main(String[] args) { List&lt;User&gt; list=new ArrayList&lt;User&gt;(); User user=new User(); user.setAge(31); user.setName("d"); user.setSal(8000.35); User user2=ne...
对集合中的对象进行排序
ITdevil的博客
08-11 1170
方法：实现Comparator接口并重写它的compare()方法，在方法内部制定排序规则。 我们有如下学生类，在不改变学生类源码的情况下，按照某种规则，对集合中存储的学生对象进行排序。 public class Student { private String id; private String name; private int chinese; priv
集合中的对象进行排序
尽此依报身，同生极乐国。
01-18 544
如果将集合中的对象进行排序，最近使用了一个简单的方法解决了，随笔记下来。 主要思路： 首先，新建类实现Comparator，这个类是做比较的关键类，一般做比较的类型 int 或 String类型。 如果属性为Int类型比较方式为 rhs.getAge() - lhs.getAge(); 如果属性为String类型方式为 rhs.getName.compareTo(lhs.Na
List根据集合内对象的ID进行排序
最新发布
qq_36749924的博客
06-08 2921
List根据集合内对象的某个属性进行排序
java按名称排序_如何在java中按名称对ArrayList值进行排序
weixin_31558841的博客
02-25 320
但这是一个如何做的示例程序 . 我假设您想先按名称排序，然后按日期排序 . 你可以把逻辑放在自定义比较器中 .import java.util.*;public class SortExample {public static class Student {public String name;public String date;public Student(String name, Strin...
根据对象名获取对象
weixin_34204057的博客
09-22 182
object o = this.GetType().GetField(name, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.IgnoreCase).GetValue(this); ...
对象集合根据某个属性排序，空的滞后
weixin_43863128的博客
04-12 212
对象集合根据某个属性排序，空的滞后 我这边的需求是根据结束时间排序，未结束节点滞后 Comparator.nullsLast(Comparator.comparing(JobBillInfoVO::getCreateDate,Comparator.nullsLast(Date::compareTo)))
list排序，根据list中存放对象的某一属性排序
热门推荐
sdzhangshulong的博客
08-12 3万+
1.Student的Bean如下： public class Student { private int age; private String name; private String weight; public String getWeight() { return weight; } public void setWeight(String weight)
JDBC通过对象的方式来获取数据库信息并读取
qq_44723773的博客
12-02 1549
Java的JDBC理论知识的以及如何使用的详细介绍 JDBC工具类的创建和使用 JDBC学习课堂笔记 在学习本博客内容之前，可以先查看前面三篇博客内容，下面的内容是创建对象之后，通过GetXxx()和SetXxx()方法，来设置数据库的连接信息。 在创建Java项目之前，先建立数据库信息，代码如下： create table tbStudent( id int PRIMARY KEY AUTO_INCREMENT, name varchar(20), age int, classid varchar
重用代码：利用Util类按对象属性排序List
"SortList<E> 是一个工具类，它提供了一个通用的方法来对List集合中的对象属性进行排序，无需在每个实体类中重写排序方法。这种方法提高了代码的复用性，使得排序操作更加便捷。SortList<E>.Sort() 方法接受一个List...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值