精华内容
下载资源
问答
  • Java中List根据指定字段排序工具类

    千次阅读 2016-11-15 15:11:53
    根据指定字段来对List进行排序

    根据指定字段来对List进行排序

    测试用的业务类(必须符合JavaBean规范):

    /**
     * 业务类
     * 
     * @author andy
     * @date 2016年11月15日
     */
    public class ChannelSituationBean implements java.io.Serializable {
    
        /**
         * 
         */
        private static final long serialVersionUID = 5754354214462805574L;
    
        private Integer id;
        private Date date;
        private int registCount;
        private Float fee;
        private float myFee;
        private Double investMoney;
        private double myInvestMoney;
        private String registChannel;
    
    //省略getter和setter
    }

    工具类

    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.Date;
    import java.util.List;
    
    /**
     * List根据指定字段排序
     * 
     * @author andy
     * @date 2016年11月16日
     */
    public class ListSortUtil<T> {
        /**
         * 支持的排序字段类型:Date,String,int,Integer,double,Double,float,Float (该泛型必须符合javabean规范)
         * 
         * @param list 要排序的集合
         * @param sortField 排序字段
         * @param sortRule 排序规则:(asc or desc)
         */
        public void mySort(List<T> list, final String sortField, final String sortRule) {
    
            Collections.sort(list, new Comparator<T>() {
    
                @Override
                public int compare(T o1, T o2) {
                    // 通过反射获取方法名称,如getId
                    String methodName = "get" + sortField.substring(0, 1).toUpperCase() + sortField.substring(1, sortField.length());
                    String flag = null;
                    try {
                        Field[] fields = o1.getClass().getDeclaredFields();
                        for (Field f : fields) {
                            if (sortField.equals(f.getName())) {
                                System.out.println(f.getName() + "  GenericType:  " + f.getGenericType().toString());
                                if (f.getGenericType().toString().equals("class java.util.Date")) {
                                    flag = "Date";
                                    break;
                                }
                                if (f.getGenericType().toString().equals("class java.lang.String")) {
                                    flag = "String";
                                    break;
                                }
                                if (f.getGenericType().toString().equals("int")) {
                                    flag = "int";
                                    break;
                                }
                                if (f.getGenericType().toString().equals("class java.lang.Integer")) {
                                    flag = "Integer";
                                    break;
                                }
                                if (f.getGenericType().toString().equals("double")) {
                                    flag = "double";
                                    break;
                                }
                                if (f.getGenericType().toString().equals("class java.lang.Double")) {
                                    flag = "Double";
                                    break;
                                }
                                if (f.getGenericType().toString().equals("float")) {
                                    flag = "float";
                                    break;
                                }
                                if (f.getGenericType().toString().equals("class java.lang.Float")) {
                                    flag = "Float";
                                    break;
                                }
                            }
                        }
    
                        Method method1 = o1.getClass().getMethod(methodName, null);
                        Method method2 = o2.getClass().getMethod(methodName, null);
                        // System.out.println(method1.invoke(o1, null));
                        // System.out.println(method2.invoke(o2, null));
                        if ("Date".equals(flag)) {
                            if ("desc".equals(sortRule)) {
                                return ((Date) method1.invoke(o1, null)).getTime() < ((Date) method2.invoke(o2, null)).getTime() ? 1 : -1;
                            } else {
                                return ((Date) method1.invoke(o1, null)).getTime() < ((Date) method2.invoke(o2, null)).getTime() ? -1 : 1;
                            }
                        } else if ("String".equals(flag)) {
                            if ("desc".equals(sortRule)) {
                                return method2.invoke(o2, null).toString().compareTo(method1.invoke(o1, null).toString());
                            } else {
                                System.out.println("compare result : " + method1.invoke(o1, null).toString().compareTo(method2.invoke(o2, null).toString()));
                                return method1.invoke(o1, null).toString().compareTo(method2.invoke(o2, null).toString());
                            }
                        } else if ("int".equals(flag) || "Integer".equals(flag)) {
                            if ("desc".equals(sortRule)) {
                                return ((Integer) method2.invoke(o2, null)).compareTo((Integer) method1.invoke(o1, null));
                            } else {
                                return ((Integer) method1.invoke(o1, null)).compareTo((Integer) method2.invoke(o2, null));
                            }
                        } else if ("double".equals(flag) || "Double".equals(flag)) {
                            if ("desc".equals(sortRule)) {
                                return ((Double) method2.invoke(o2, null)).compareTo((Double) method1.invoke(o1, null));
                            } else {
                                return ((Double) method1.invoke(o1, null)).compareTo((Double) method2.invoke(o2, null));
                            }
                        } else if ("float".equals(flag) || "Float".equals(flag)) {
                            if ("desc".equals(sortRule)) {
                                return ((Float) method1.invoke(o1, null)) < ((Float) method2.invoke(o2, null)) ? 1 : -1;
                            } else {
                                return ((Float) method1.invoke(o1, null)) < ((Float) method2.invoke(o2, null)) ? -1 : 1;
                            }
                        }
                    } catch (NoSuchMethodException | SecurityException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IllegalArgumentException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    return 0;
                }
            });
    
        }
    
        public static void main(String[] args) throws ParseException {
            // TODO Auto-generated method stub
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            ChannelSituationBean cs = new ChannelSituationBean();
            cs.setId(1);
            cs.setDate(sdf.parse("2012-10-09"));
            cs.setRegistCount(15);
            cs.setFee(3f);
            cs.setInvestMoney(300.00);
            cs.setRegistChannel("android");
            cs.setMyFee(3f);
            cs.setMyInvestMoney(299.99);
    
            //
            ChannelSituationBean cs1 = new ChannelSituationBean();
            cs1.setId(2);
            cs1.setDate(sdf.parse("2016-10-09"));
            cs1.setRegistCount(8);
            cs1.setFee(6f);
            cs1.setInvestMoney(600.00);
            cs1.setRegistChannel("android");
            cs1.setMyFee(5.8f);
            cs1.setMyInvestMoney(588.23);
    
            //
            ChannelSituationBean cs2 = new ChannelSituationBean();
            cs2.setId(3);
            cs2.setDate(sdf.parse("2014-10-09"));
            cs2.setRegistCount(6);
            cs2.setFee(9f);
            cs2.setInvestMoney(500.05);
            cs2.setRegistChannel("weixin");
            cs2.setMyFee(8.88f);
            cs2.setMyInvestMoney(488.00);
    
            //
            ChannelSituationBean cs3 = new ChannelSituationBean();
            cs3.setId(4);
            cs3.setDate(sdf.parse("2015-02-15"));
            cs3.setRegistCount(10);
            cs3.setFee(8f);
            cs3.setInvestMoney(500.02);
            cs3.setRegistChannel("ios");
            cs3.setMyFee(7.99f);
            cs3.setMyInvestMoney(488.99);
    
            List<ChannelSituationBean> m_list = new ArrayList<ChannelSituationBean>();
            m_list.add(cs);
            m_list.add(cs1);
            m_list.add(cs2);
            m_list.add(cs3);
    
            new ListSortUtil<ChannelSituationBean>().mySort(m_list, "myFee", "asc");
    
            // Collections.sort(m_list, new Comparator<ChannelSituationBean>() {
            // @Override
            // public int compare(ChannelSituationBean o1, ChannelSituationBean o2) {
            // return o1.getRegistCount() < o2.getRegistCount() ? 1 : -1;
            // }
            // });
            System.out.println("--------------");
            for (ChannelSituationBean csb : m_list) {
                System.out.println("myFee : " + csb.getMyFee() + "----" + "myInvestMoney : " + csb.getMyInvestMoney() + "----" + sdf.format(csb.getDate()));
                // System.out.println("registCount : " + csb.getRegistCount() + "----" + csb.getRegistChannel() + "----id :"
                // + csb.getId());
            }
    
        }
    
    }
    展开全文
  • 如果item.get(sortField) 有时间,有数字的时候直接toString(),数组结果的排序结果可能不正确 List<Map<String, Object>> resourceCatalogFrontVoList = resourceMapper.selectPublish...

    今天项目中用到了,特记录一下

    一. List<Map>

    如果 item.get(sortField) 有时间,有数字的时候直接toString(),数组结果的排序结果可能不正确

    List<Map<String, Object>> resourceCatalogFrontVoList = resourceMapper.selectPublishResourceCatalogList(keyWord, sysId, shareType, openAttribute,
                    classifyId, resourceType, page);
            //排序
            Comparator<Map<String, Object>> comparator = Comparator.comparing(item -> item.get(sortField).toString());
            if (FrontConstant.SORT_TYPE_ASC == sortType){
                //升序
                resourceCatalogFrontVoList.sort(comparator);
            }else {
                resourceCatalogFrontVoList.sort(comparator.reversed());
            }
            //分页
            return page.setRecords(resourceCatalogFrontVoList);

    补充

    if (FrontConstant.SORT_TYPE_ASC == sortType){
                //升序
                Collections.sort(resourceCatalogFrontVoList, Comparator.comparing(
                        item -> item.get(sortField).toString()));
            }else {
                Collections.sort(resourceCatalogFrontVoList, Comparator.comparing(
                        item -> item.get(sortField).toString(), Comparator.reverseOrder()));
            }

     

     

    二.List<entity>

    
    
    List<ResMessageVo> messageVoList = messageMapper.selectUnReadMessage(null, null, null, MessageConstant.MESSAGE_TYPE_MOUNT_RESOURCE_RESULT);

    //排序
            Comparator<ResMessageVo> comparator = Comparator.comparing(item -> item.getCreateTime());
            if (FrontConstant.SORT_TYPE_ASC == sortType){
                //升序
                messageVoList.sort(comparator);
            }else {
                messageVoList.sort(comparator.reversed());
            }

     

    转载于:https://www.cnblogs.com/cailijuan/p/11412722.html

    展开全文
  • import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;.../*** List根据指定字段进行排序**/public class ListStreamTest {public sta...

    import java.util.ArrayList;

    import java.util.Collections;

    import java.util.Comparator;

    import java.util.List;

    import com.wubei.demo.bean.Order;

    /**

    * List根据指定字段进行排序

    *

    */

    public class ListStreamTest {

    public static void main(String[] args) {

    String orderId1 = "2321837281372913";

    String userId1 = "20180701001";

    String orderId2 = "2321837281372914";

    String userId2 = "20180701002";

    String orderId3 = "2321837281372912";

    String userId3 = "20180701003";

    String orderId4 = "2321837281372918";

    String userId4 = "20180701005";

    String orderId5 = "2321837281372918";

    String userId5 = "20180701004";

    Order order = new Order();

    order.setUserId(userId1);

    order.setOrderId(orderId1);

    Order order1 = new Order();

    order1.setOrderId(orderId2);

    order1.setUserId(userId2);

    Order order2 = new Order();

    order2.setOrderId(orderId3);

    order2.setUserId(userId3);

    Order order3 = new Order();

    order3.setOrderId(orderId4);

    order3.setUserId(userId4);

    Order order4 = new Order();

    order4.setOrderId(orderId5);

    order4.setUserId(userId5);

    List orderList = new ArrayList();

    orderList.add(order);

    orderList.add(order1);

    orderList.add(order2);

    orderList.add(order3);

    orderList.add(order4);

    //1.jdk8 lambda排序,带参数类型

    orderList.sort(( Order ord1, Order ord2) -> ord2.getOrderId().compareTo(ord1.getOrderId()));

    //2.jdk8 lambda排序,不带参数类型

    orderList.sort(( ord1, ord2) -> ord2.getOrderId().compareTo(ord1.getOrderId()));

    //3.jdk8 升序排序,Comparator提供的静态方法

    Collections.sort(orderList, Comparator.comparing(Order::getOrderId));

    //4.jdk8 降序排序,Comparator提供的静态方法

    Collections.sort(orderList, Comparator.comparing(Order::getOrderId).reversed());

    //5.jdk8 组合排序,Comparator提供的静态方法,先按orderId排序,orderId相同的按userId排序

    Collections.sort(orderList, Comparator.comparing(Order::getOrderId).reversed().thenComparing(Order::getUserId));

    orderList.stream().forEach(str -> System.out.println(str.getOrderId()+"/" + str.getUserId()));

    }

    }

    展开全文
  • //json 字符串 String dd = "[{id:1,adress:上海,age:21},{id:2,adress:上海,age:32},{id:3,adress:上海,age:28},{id:4,adress:上海,age...//根据age升序序排序 listObjectFifth.sort(Comparator.comparing(obj -> .
    //json 字符串
    String dd = "[{id:1,adress:上海,age:21},{id:2,adress:上海,age:32},{id:3,adress:上海,age:28},{id:4,adress:上海,age:27}]";
    
    //字符串转对象
    JSONArray listObjectFifth = JSONObject.parseArray(dd);
    
    //根据age升序序排序
    listObjectFifth.sort(Comparator.comparing(obj -> ((JSONObject) obj).getBigDecimal("age")));
    
    //根据age降序排序
    listObjectFifth.sort(Comparator.comparing(obj -> ((JSONObject) obj).getBigDecimal("age")).reversed());

     

    展开全文
  • 1.js进行排序 var arr=[ {num:3,name:"排序3"}, {num:1,name:"排序1"}, ...//指定元素排序 function compare(property){ return function(a,b){ var value1 = a[property]; var value2 = b[property];
  • 之前写过一篇博客 【Java实现 根据list列表元素的时间字段进行排序】,其中是用的java自带的集合工具类[java.util.Collections]对list列表元素的指定属性进行排序,最近刚刚翻看源码,发现Collections这个工具类的...
  • PHP中有一些函数可以用来对数组进行排序。sort() - 对数组进行升序排列rsort() - 对数组进行降序排列asort() - 根据关联数组的值,对数组进行升序排列ksort() - 根据关联数组的键,对数组进行升序排列arsort() - ...
  • JDK1.8对List指定字段进行排序 import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List;...* List根据指定字段进行排序 * */ public...
  • 二、根据对象指定字段分组排序 使用java stream 计算的过程如下图: 下面是实现的代码示例: /** * 定义一个对象,这里使用了lombok的注解 */ @Data @Accessors(chain = true) class Good { priv
  • FastJson序列化java bean中的属性顺序问题(alibaba.fastjson)fastjson序列化一个java bean,默认是根据fieldName的字母序进行序列化的,你可以通过ordinal指定字段的顺序,这个特性需要1.1.42以上版本。示例如下。...
  • List集合存入的多个对象,要使其对象中根据指定字段进行升序或者降序。将使用 Collections.sort(); 方法。 首先看Collections的常用方法: package com.company; import java.util.ArrayList; import java.util....
  • java8的lambda表达式提供了一些方便list操作的方法,...分组通过groupingBy可以分组指定字段2.过滤通过filter方法可以过滤某些条件 List userCommonList = userList.stream().filter(a -> !a.getJobNumber().eq...
  • ,需要获取Employee的字段 name出现最多的对象(即根据name字段分组->排序->取第一个对象); public static void main(String[] args) { List<Employee> list = new ArrayList(){{ add(new Employee...
  • 1. 根据集合中对象的某个属性值, 排序 List<... //进行排序, 按照指定字段升序排列 Collections.sort(roomCartypeParamtersList, new Comparator<RoomCartypeParamters>() { @Override
  • java.lang.Object findFirstByProperty(java.lang.Classcls, java.lang.StringpropertyName, java.lang.StringpropertyValue, ...
  • 要求:查询t_user表中指定boxId的mobile和msg字段根据状态(state)排序并分页DAO层:@Query(value = "SELECT r.mobile,r.msg FROM t_user r WHERE r.boxId =:boxId", countQuery = "SELECT COUNT...
  • java.util.List findAllByPropertys(java.lang.Classcls, java.util.Map<java.lang.String,java.lang.Object[]>params, java.lang.S...
  • sqlite不支持中文排序,改用java排序 根据指定的对象属性字段排序对象集合,顺序
  • 排序的User bean要实现Comparable接口,重写 compareTo方法,面试过程中被问到的时候很可能会思考短路哦 package com.jiaocaigen; import java.util.*; public class SortTest { ...
  • )一、根据List 中的Student对象中的开始时间进行排序。注意,该类只给Date类型属性字段进行排序。代码如下:说明:自定义类名:DateSortList ,方法名:sortByAttribute,参数1:List,即你需要进行排序的List。参数2...
  • )一、根据List 中的Student对象中的开始时间进行排序。注意,该类只给Date类型属性字段进行排序。代码如下:说明:自定义类名:DateSortList ,方法名:sortByAttribute,参数1:List,即你需要进行排序的List。参数2...
  • 很实用的一个List集合排序类。(本作品为原创,如有...注意,该类只给Date类型属性字段进行排序。代码如下: 说明:  自定义类名:DateSortList ,方法名:sortByAttribute,参数1:List,即你需要进行排序的Lis...
  • java8的lambda表达式提供了一些方便list操作的方法,主要...通过groupingBy可以分组指定字段,可以指定多个数量的字段 //根据订单号进行分组 Map<String, List<OrderHeader>> groupByDDHM1 = orderH...
  • java实现简单的Dag图

    2020-12-17 12:03:03
    基于java进行的实现简单Dag图;附件中包含java根据配置的dagJson。1实现了filter过滤,...2实现了按指定字段排序,返回指定的字段;可以自己添加mysql、Oracle、redis、hive、es、sparksql、clickhouse等存储进来运算

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 127
精华内容 50
关键字:

java根据指定字段排序

java 订阅