集合排序

最新推荐文章于 2021-08-20 06:53:36 发布
最新推荐文章于 2021-08-20 06:53:36 发布
阅读量147 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JaHunter1/article/details/84505230
版权
集合排序(BigDecimal、根据对象某个属性排序)
 
 
      /**
      * 按照属性property给list排序
      * 支持的属性类型:Short Integer Long Float Double BigDecimal Date
      *  @param  <E>
      *  @param  list
      *  @param  property
      *  @param  clazz
      *  @param  ascOrDesc  (true 是 asc, false 是 desc)
      */
      public  static <E>  void  sortList(List<E> list,  final  String property,  final  boolean  ascOrDesc) {
           
             if  (list ==  null  || list.isEmpty()) {
                return ;
           }
           
           Collections. sort(list,  new  Comparator<E>() {
 
                  @Override
                  public  int  compare(E o1, E o2) {
                       try  {
                           Field field1 = o1.getClass().getField(property);
                           Field field2 = o2.getClass().getField(property);
                             try  {
                                Class<?> clazz =  field1.get(o1).getClass();
                                  if  (clazz == Short.  class  || clazz == Integer. class  || clazz == Long. class
                                           || clazz == Float. class  || clazz == Double. class ) {
                                       if  (ascOrDesc) {       //asc
                                             return  field1.getInt(o1) - field2.getInt(o2);
                                     }  else  {               //desc
                                             return  field2.getInt(o2) - field1.getInt(o1);               
                                     }    
                                }
                                  if  (clazz == BigDecimal.  class ) {
                                     BigDecimal b1 = (BigDecimal)field1.get(o1);
                                     BigDecimal b2 = (BigDecimal)field2.get(o2);
                                       if  (ascOrDesc) {       //asc
                                             return  b1.compareTo(b2);
                                     }  else  {               //desc
                                             return  b2.compareTo(b1);               
                                     }    
                                }
                                  if  (clazz == Date.  class ) {
                                     Date b1 = (Date)field1.get(o1);
                                     Date b2 = (Date)field2.get(o2);
                                       if  (ascOrDesc) {       //asc
                                             return  b1.compareTo(b2);
                                     }  else  {               //desc
                                             return  b2.compareTo(b1);               
                                     }    
                                }
                           }  catch  (IllegalArgumentException e) {
                                e.printStackTrace();
                           }  catch  (IllegalAccessException e) {
                                e.printStackTrace();
                           }
                     }  catch  (SecurityException e) {
                           e.printStackTrace();
                     }  catch  (NoSuchFieldException e) {
                           e.printStackTrace();
                     }
                     
                       return  0;
                }
                
           });
     }
     
      /**
      * 按照属性property给array排序
      * 支持的属性类型:Short Integer Long Float Double BigDecimal Date
      *  @param  <E>
      *  @param  e
      *  @param  property
      *  @param  ascOrDesc (true 是 asc, false 是 desc)
      */
      public  static <E>  void  sortArray(E[] e,  final  String property,  final  boolean  ascOrDesc) {
           
             if  (e ==  null  || e.  length  == 0) {
                return ;
           }
           
           Arrays. sort(e,  new  Comparator<E>() {
 
                  @Override
                  public  int  compare(E o1, E o2) {
                       try  {
                           Field field1 = o1.getClass().getField(property);
                           Field field2 = o2.getClass().getField(property);
                             try  {
                                Class<?> clazz =  field1.get(o1).getClass();
                                  if  (clazz == Short.  class  || clazz == Integer. class  || clazz == Long. class
                                           || clazz == Float. class  || clazz == Double. class ) {
                                       if  (ascOrDesc) {       //asc
                                             return  field1.getInt(o1) - field2.getInt(o2);
                                     }  else  {               //desc
                                             return  field2.getInt(o2) - field1.getInt(o1);               
                                     }    
                                }
                                  if  (clazz == BigDecimal.  class ) {
                                     BigDecimal b1 = (BigDecimal)field1.get(o1);
                                     BigDecimal b2 = (BigDecimal)field2.get(o2);
                                       if  (ascOrDesc) {       //asc
                                             return  b1.compareTo(b2);
                                     }  else  {               //desc
                                             return  b2.compareTo(b1);               
                                     }    
                                }
                                  if  (clazz == Date.  class ) {
                                     Date b1 = (Date)field1.get(o1);
                                     Date b2 = (Date)field2.get(o2);
                                       if  (ascOrDesc) {       //asc
                                             return  b1.compareTo(b2);
                                     }  else  {               //desc
                                             return  b2.compareTo(b1);               
                                     }    
                                }
                           }  catch  (IllegalArgumentException e) {
                                e.printStackTrace();
                           }  catch  (IllegalAccessException e) {
                                e.printStackTrace();
                           }
                     }  catch  (SecurityException e) {
                           e.printStackTrace();
                     }  catch  (NoSuchFieldException e) {
                           e.printStackTrace();
                     }
                     
                       return  0;
                }
                
           });
     }
     
      /**
      * 直接用Collections.sort(list  <BigDecimal> );即可,如果是BigDecimal数组则需要像下面这样重写
      *  @param  bds
      *  @param  ascOrDesc
      */
      public  static  void  sortBigDecimalArray(BigDecimal[] bds,  final  boolean  ascOrDesc) {
           
             if  (bds ==  null  || bds.  length  == 0) {
                return ;
           }
           
           Arrays. sort(bds,  new  Comparator<BigDecimal>() {
 
                  @Override
                  public  int  compare(BigDecimal o1, BigDecimal o2) {
                       if  (ascOrDesc) {       //asc
                             return  o1.compareTo(o2);
                     }  else  {               //desc
                             return  o2.compareTo(o1);                        
                     }
                }
           });
           
     }
JaHunter1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BigDecimal的最大值，最小值，中位数，排序操作
weixin_43588364的博客
05-01 9935
BigDecimal的最大值，最小值，中位数，排序操作 由于使用double数组对数据进行操作会引起精度损失，所以使用BigDecimal 进行计算 package com.test.annotation.test.test; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collection...
java中集合排序
12-22
java中集合排序
Java基础练习（十二）集合与数组工具类使用，BigDecimal使用，实现二分查找，快速排序
My的博客
08-20 526
1、使用Collections中的方法，完成List集合的排序，然后反转。 public class Test { public static void main(String[] args) { List list= Arrays.asList(1,2,5,9,0,6,8,44,1); Collections.sort(list); Collections.reverse(list); System.out.println(list)
Collections排序BigDecimal
热门推荐
----------
12-15 1万+
public static void main(String[] args) {            ArrayList> layerselectList= new ArrayList>(8);            HashMap tempMap=new HashMap();                 tempMap = new HashMap();             
使用stream流进行集合排序取最大值，根据集合中的bigdemal属性排序（正序反序）并取最大值
qq_39143103的博客
07-09 6075
业务： 求折线图的UPH图相关数据，前端动态修改纵轴的峰值，需要后端获取最大值 1）根据集合某个属性（业务以bigdecimal数据为例）进行集合排序，包括升序反序 2）根据集合的某个number数值属性取最大值 实体类： @Data public class EqpUPHVO { @ApiModelProperty(value = "设备名称") private String eqpName; @ApiModelProperty(value = "uph值"...
集合之排序
Zz_0_o的博客
08-28 185
今天遇到了一点问题，刚好需要对集合排序，突然之间就不知道怎么办了，时候自己百度了一下。首先是最简单的基本类型的排序： package cn.http.sort; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Demo { public st...
List集合排序222222
01-24
导入jar 包 调用 String[] arr1 = new String[1]; ... 参数1 排序的集合 参数2 排序的字段(与定义字段一致) 可多个 参数3 排序方式(asc desc) 暂时只支持String 和int的排序 可能有些BUG 敬请谅解
Java8 用Lambda表达式给List集合排序的实现
08-25
主要介绍了Java8 用Lambda表达式给List集合排序的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java常用工具类—集合排序
08-26
主要介绍了Java集合排序，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java List集合排序实现方法解析
08-25
主要介绍了Java List集合排序实现方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java中的2种集合排序方法介绍
09-04
主要介绍了Java中的2种集合排序方法介绍,本文直接给出代码,相关说明请看代码中的注释,需要的朋友可以参考下
java中进行集合排序
10-13
java中按找对象的某个属性进行升序降序的排序
Java sort集合排序的两种方式解析
08-25
主要介绍了Java sort集合排序的两种方式解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
HashMap集合排序
11-11
练习TreeMap,创建一个小车类 ，有型号、速度属性，汽车类作为Key，速度作为vauel,先按速度排序，速度一样按型号排：
Java：集合排序（正序、倒序）的方法
10-17
java 对象集合按字段排序
Java对List集合进行排序
微风轻轻吹拂的博客
03-29 3653
这几天做题刚好遇到对List集合排序的题，发现一种好用的方法，做一个笔记。 我是基于spring，对于刚学java的小伙伴可以直接在main方法中去完成。 第一步 创建一个实体类对象User package bean; public class User { private String username; private Integer age; public Us...
Java 集合类型排序
pan_xi_yi的博客
04-22 234
自定义对象的集合排序 public class Person { Integer age; String name; public Person(Integer age, String name) { this.age = age; this.name = name; } public Integer getAge() ...
Java集合排序
楚辉的博客
07-29 235
1、普通集合排序 //集合排序-升序 工具类 Collections List<String> ids = new ArrayList<>(); ids.add("13"); ids.add("23"); ids.add("18"); Collections.sort(ids); //数组排序...
常用类（三）
weixin_30559481的博客
01-25 119
Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。 人们对于时间的认识是：某年某月某日，这样的日期概念。...
集合排序stream
最新发布
10-19
集合排序stream是一种Java 8中的新特性，它可以通过Stream()对集合进行升序或者降序操作。在排序时，我们可以使用Comparator.comparing()方法来指定按照哪个属性进行排序，也可以使用reversed()方法来实现降序排序。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值