在JAVA中针对LIST进行排序

最新推荐文章于 2024-12-16 08:03:38 发布
最新推荐文章于 2024-12-16 08:03:38 发布
阅读量858 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JAVA 文章标签： JAVA排序 LIST排序 list 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/songbob/article/details/78352817
介绍了一种基于Collections.sort方法的Java列表排序工具，该工具支持int、double、string和date等类型的单列排序，并提供了升序和降序的功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

工作原因，需要针对实时爬取的数据进行排序，而这些数据没有存在于DB中。所以，就要在JAVA中进行排序。

为此，写了一个基于Collections.sort来排序的方法。

说明：

1 当数据没有存在于DB中采用此种排序。

2 本排序只提供单列，不提供复合，有需要的可以自行重写。

3 本排序基于Collections.sort，重写Comparator()来实现。

4 排序针对于LIST，参数为：LIST,字段名，字段类型，升/降序。

5 排序支持类型为 int,double,string,date


主方法： SortListUitl.java


package com.xbniao.analysis.compare.common.util.sort;

import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

public class SortListUtil<E> {
    public static final String FIELD_TYPE_INTEGER = "Integer";
    public static final String FIELD_TYPE_STRING = "String";
    public static final String FIELD_TYPE_DOUBLE = "Double";
    public static final String FIELD_TYPE_DATE = "Date";
    public static final String FIELD_SORT_ASC = "asc";
    public static final String FIELD_SORT_DESC = "desc";
    /**
     * Sort 本排序只支持单列排序，不支持复合排序
     * @param list 排序list
     * @param field 排序字段
     * @param fieldType 字段类型
     * @param sort 升、降序
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public void sort(List<E> list, String field, final String fieldType, final String sort) {
        if (CollectionUtils.isEmpty(list) || StringUtils.isBlank(field))  {
            return;
        }
        String firstChar = field.substring(0,1).toUpperCase();
        field = "get" + firstChar + field.substring(1);
        final String method = field;
        Collections.sort(list, new Comparator() {
            public int compare(Object o1, Object o2) {
                int result = 0;
                if (null != o1 && null != o2) {
                    try {
                        Object obj1 = ReflectUtils.getObjectValue(o1, method);
                        Object obj2 = ReflectUtils.getObjectValue(o2, method);
                        if (FIELD_TYPE_INTEGER.equals(fieldType)) {
                            // Integer型比较
                            int num1;
                            int num2;
                            if (obj1 instanceof Integer) {
                                num1 = (Integer) obj1;
                                num2 = (Integer) obj2;
                            } else {
                                num1 = 0;
                                num2 = 0;
                                if ((obj1 instanceof String) && StringUtils.isNotEmpty(String.valueOf(obj1))) { 
                                    num1 = Integer.parseInt(obj1.toString());
                                }
                                if ((obj2 instanceof String) && StringUtils.isNotEmpty(String.valueOf(obj2))) { 
                                    num2 = Integer.parseInt(obj2.toString());
                                }
                            }
                            if (obj1 == null || obj2 == null) {
                                if (obj1 == null) result = -1;
                                if (obj2 == null) result = 1;
                            } else {
                                if (num1 > num2) {
                                    result = 1;
                                } else if (num1 < num2) {
                                    result = -1;
                                } else {
                                    result = 0;
                                }
                            }
                        } else if (FIELD_TYPE_DOUBLE.equals(fieldType)) {
                            // DOUBLE 型比较
                            BigDecimal num1;
                            BigDecimal num2;
                            if (obj1 instanceof Double) {
                                num1 = new BigDecimal((Double) obj1);
                                num2 = new BigDecimal((Double) obj2);
                            } else {
                                num1 = new BigDecimal(0);
                                num2 = new BigDecimal(0);
                                if ((obj1 instanceof String) && StringUtils.isNotEmpty(String.valueOf(obj1))) {
                                    num1 = new BigDecimal(Double.parseDouble(obj1.toString()));
                                }
                                if ((obj2 instanceof String) && StringUtils.isNotEmpty(String.valueOf(obj2))) {
                                    num2 = new BigDecimal(Double.parseDouble(obj2.toString()));
                                }
                            }
                            if (obj1 == null || obj2 == null) {
                                if (obj1 == null) result = -1;
                                if (obj2 == null) result = 1;
                            } else {
                                result = num1.compareTo(num2);
                            }
                        } else if (FIELD_TYPE_DATE.equals(fieldType)) {
                            // Date 型比较
                            DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                            Date dt1 = df.parse(String.valueOf(obj1));
                            Date dt2 = df.parse(String.valueOf(obj2));
                            if (dt1.getTime() > dt2.getTime()) {
                                result = 1;
                            } else if (dt1.getTime() < dt2.getTime()) {
                                result = -1;
                            } else {
                                result = 0;
                            }
                        } else {
                            // String 型比较
                            if (obj1 == null || obj2 == null) {
                                if (obj1 == null) result = -1;
                                if (obj2 == null) result = 1;
                            } else {
                                result = obj1.toString().compareTo(obj2.toString());
                            }
                        }
                    } catch (SecurityException e) {
                        e.printStackTrace();
                    } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                }
                // 排序设置
                if (FIELD_SORT_DESC.equals(sort)) {
                    if (result < 0) {
                        return 1;
                    } else if (result > 0) {
                        return -1;
                    }
                }
                return result/* 等于 */;
            }
        });
    }
}



反射方法：ReflectUtils.java
package com.test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectUtils {

    public static Object getObjectValue(Object o1, String method) {
        try {
            Method method = o1.getClass().getMethod(method, null);
            return method.invoke(o1);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        return new Object();
    }
}

操作： 


        SortListUtil <testList> sortList = new SortListUtil<testList>();
        sortList.sort(abcList, "name",SortListUtil.FIELD_TYPE_STRING , SortListUtil.FIELD_SORT_ASC);

本文参考了

http://www.cnblogs.com/huangwei520/p/4868934.html

对此表示感谢。

java对list进行排序
qq_183574716的博客
08-18 9190
1、先来个简单的，上代码 //list排序 public static void listsort5(){ List listarr = new ArrayList<>(); listarr.add(1); listarr.add(3); listarr.add(5); listarr.add(7); listarr.add(2); listarr.add(4); listarr.add(6); System.out.println("list排
Java List返回Map List中文数字排序 List返回JSONString
weixin_45409897的博客
08-02 514
JAVA对List传入任意对象list和对应字段返回对应Map并且重排序(中文一二三四五六七八九十 排序)和返回对应字段list去重数据多层json
java 对list进行排序
weixin_30779691的博客
10-11 89
前提: list中的元素是自定义对象,如何根据对象的元素进行排序呢? 比如List<Student>students 是一个list,每个元素都是Student对象,Student对象中有成员变量name,age,等, 那么我想根据age来排序,如何实现呢? 1,使用Comparator 接口 Student类 结构如下:(省略getter,setter方法) publ...
java中对list进行排序
weixin_34297300的博客
08-28 157
为什么80%的码农都做不了架构师？>>> ...
java List 排序 Collections.sort()
SalmonellaVaccine的专栏
12-23 842
http://blog.youkuaiyun.com/zxy_snow/article/details/7232035 用Collections.sort方法对list排序有两种方法  第一种是list中的对象实现Comparable接口，如下： [java] view plaincopy /**   * 根据order对User排序 
Java使用Collections工具类对List集合进行排序
08-25
Java使用Collections工具类对List集合进行排序是Java编程中一个常见的操作。Collections工具类提供了一个sort方法，可以对List集合进行排序。下面我们将详细介绍如何使用Collections工具类对List集合进行排序。 一...
java List 排序 Collections.sort
03-26
总结起来，`Collections.sort()`是Java中对List进行排序的标准工具，它支持自然排序和自定义排序。了解其工作原理和优化技巧，可以帮助我们在编程实践中更高效地处理数据。通过阅读和理解`Collections.sort()`的源码...
Java 元素排序（数组、List 集合）
qq_44378854的博客
04-06 573
List 集合中的元素是 Integer、Float、Double、String 类型时，都可以使用 Collections.sort() 来对元素进行排序。可以先将数组元素存入 List 集合，然后集合元素逆序，最后将集合元素写回原数组。（List 集合元素逆序的讲解在下面）Collections.sort() 默认对元素进行升序排序，若需要降序排序，就需要提供一个比较器。
Java针对ArrayList自定义排序的2种实现方法
08-28
Java针对ArrayList自定义排序的2种实现方法 Java语言中提供了多种方式来实现ArrayList的自定义排序，今天我们将介绍其中的两种实现方法。首先，让我们了解一下ArrayList的基本概念。ArrayList是一种动态数组，能够...
java中List进行排序
Alain999的博客
10-20 537
方法1： List<RainConditionDetailInfoDto> detailInfoList = new ArrayList<>(); //将数据按字段正序排序 detailInfoList.sort(Comparator.comparing(RainConditionDetailInfoDto::getDayDrp)); //将数据按字段正序排序(注意字段为null时) List<User> nullsLastCollect = userList.
Java中对List进行排序
技术崛起
05-19 579
需求：一组用户对象User放在List中，这组用户对象需要排序，先按照用户的年龄来排序，如果年龄一样的话按照id排序。  用户实体类    package test; public class User {  private int id;  //用户id  private int age; //用户年
Java的集合排序：Collections.sort、list.sort和list.stream().sorted方法详解
热门推荐
帝上无天的博客
10-17 1万+
在工作中我们经常需要对集合中的元素进行比较排序，下面就java中常用的排序方法进行详解。 主要有三种用法： // 第一种 Collections.sort(studentList); // 第二种 studentList.sort(Comparator.comparing(Student::getAge).reversed()); // 第三种 List<Student> studentList = studentList.stream().sorted(Comparator .compa
java List集合排序
cdc的博客
03-16 680
使用Collections.sort进行排序 import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class SetSortTools { public static List<BluetoothDevice> getListBluetoothDevice(){ List<Blueto
Java中List排序的3种方法
2401_89690362的博客
12-16 2024
下面我们分别来看各种排序方法的具体实现。1.使用 Comparable 排序按照本文设计的场景，我们需要创建一个包含了用户列表的 List 集合，并按用户的年龄从大到小进行排序，具体实现代码如下：// 创建并初始化 Listadd(new Person(1, 30, “北京”));add(new Person(2, 20, “西安”));add(new Person(3, 40, “上海”));}};// 使用 Comparable 自定的规则进行排序// 打印 list 集合})
Java对List集合进行排序
微风轻轻吹拂的博客
03-29 3771
这几天做题刚好遇到对List集合排序的题，发现一种好用的方法，做一个笔记。 我是基于spring，对于刚学java的小伙伴可以直接在main方法中去完成。 第一步 创建一个实体类对象User package bean; public class User { private String username; private Integer age; public Us...
java list<> 排序_java List的排序
weixin_42127775的博客
02-16 197
项目中输出报表时，需要对List进行排序。由于报表数据是分段获取的，不能在获取时排序，只能在输出时排序。有两种情况，一种是表头排序，另一种数据。表头，可以使用如下方法,先定义原始数据表头，在输出时位于第几列：private static final Map PERSONAL_SORT = new HashMap<>();static {PERSONAL_SORT.put("表头1", ...
java针对list排序
最新发布
08-09
在 Java 中对 `List` 进行排序，可以通过多种方法实现，具体取决于使用场景、Java 版本以及是否需要自定义排序逻辑。以下是几种常见的排序方式： ### 使用 `Collections.sort()` 方法排序 对于简单的类型如 `String` 或 `Integer`，可以直接使用 `Collections.sort()` 方法进行排序： ```java List<String> names = new ArrayList<>(); List<Integer> ages = new ArrayList<>(); Collections.sort(names); Collections.sort(ages); ``` 此方法适用于不需要自定义排序规则的情况，且数据类型本身已经实现了 `Comparable` 接口[^1]。 ### 实现 `Comparable` 接口进行排序 如果需要对自定义对象进行排序，可以在类中实现 `Comparable` 接口，并重写 `compareTo()` 方法。例如，对于一个 `User` 类： ```java public class User implements Comparable<User> { private String name; public int compareTo(User user) { return this.getName().compareTo(user.getName()); // 按名称升序排列 } } ``` 然后可以使用 `Collections.sort(users)` 对 `User` 列表进行排序。此方法的缺点是只能定义一种排序规则，并且修改需要在类内部进行[^1]。 ### 使用 `Comparator` 接口进行排序 为了实现更灵活的排序规则，可以创建一个实现了 `Comparator` 接口的类或匿名内部类来定义排序逻辑： ```java public class UserComparator implements Comparator<User> { @Override public int compare(User o1, User o2) { if (o1.getAge() > o2.getAge()) return 1; else if (o1.getAge() == o2.getAge()) { if (o1.getId() > o2.getId()) return 1; else if (o1.getId() == o2.getId()) return 0; else return -1; } else return -1; } } UserComparator comp = new UserComparator(); Collections.sort(users, comp); ``` 此方法允许在不修改原有类的情况下定义多种排序规则[^1]。 ### 使用 Java 8 的 Lambda 表达式 Java 8 引入了 Lambda 表达式，使得排序代码更加简洁： ```java List<User> users = ...; users.sort((u1, u2) -> u1.getName().compareTo(u2.getName())); ``` 或者使用方法引用： ```java users.sort(Comparator.comparing(User::getName)); ``` 还可以进行逆序排序： ```java users.sort(Comparator.comparing(User::getName).reversed()); ``` ### 使用 Stream API 排序 Java 8 还引入了 Stream API，可以使用 `sorted()` 方法来排序： ```java List<Person> sortedList = list.stream() .sorted(Comparator.comparing(Person::getAge).reversed()) .collect(Collectors.toList()); ``` 这种方法非常适合链式调用和进一步的数据处理[^3]。 ### 使用 Comparator 的方法引用 对于多属性排序，可以利用 `Comparator` 的组合方法： ```java users.sort(Comparator.comparing(User::getAge).thenComparing(User::getName)); ``` 这种方法可以先按年龄排序，如果年龄相同，则按名字排序[^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值