java 实现Comparable接口排序,升序、降序、倒叙

2023-07-18 13:45:03 349

本人由于项目开发中需要对查询结果list进行排序，这里根据的是每一个对象中的创建时间降序排序。本人讲解不深，只实现目的，如需理解原理还需查阅更深的资料。

1.实现的效果

2.创建排序的对象

packagecom.practice.test.comparable;
importjava.util.Date;

/**
*描述:要比较的对象
*
*@authorcui
*@create2018-12-1814:07
*/
publicclassMySortBeanimplementsComparable{
privateStringname;
privateintage;
privateDatecreateTime;


publicStringgetName(){
returnname;
}

publicvoidsetName(Stringname){
this.name=name;
}

publicintgetAge(){
returnage;
}

publicvoidsetAge(intage){
this.age=age;
}

publicDategetCreateTime(){
returncreateTime;
}

publicvoidsetCreateTime(DatecreateTime){
this.createTime=createTime;
}

//@Override
//publicintcompareTo(MySortBeano){
//if(this.age>o.age){
//return-1;
//}elseif(this.age==o.age){
//return0;
//}
//return1;
//}
@Override
publicintcompareTo(MySortBeano){
if(this.createTime.compareTo(o.getCreateTime())>0){
return-1;
}elseif(this.createTime.compareTo(o.getCreateTime())==0){
return0;
}
return1;
}

@Override
publicStringtoString(){
return"MySortBean{"+
"name='"+name+'\''+
",age="+age+
'}';
}
}

3.编写test方法

packagecom.practice.test;
importcom.practice.test.comparable.MySortBean;
importcom.spring.testlist.util.DateUtil;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;

importjava.util.ArrayList;
importjava.util.Date;
importjava.util.List;

/**
*描述:
*测试比较器
*
*@authorcui
*@create2018-12-1814:10
*/
@RunWith(SpringJUnit4ClassRunner.class)
publicclassTestCompare{

@Test
publicvoidtestComparable(){
MySortBeanm1=newMySortBean();
m1.setAge(1);
m1.setCreateTime(DateUtil.parseDate("2019-01-2116:13:18"));
MySortBeanm2=newMySortBean();
m2.setAge(2);
m2.setCreateTime(DateUtil.parseDate("2019-01-2316:13:18"));
MySortBeanm3=newMySortBean();
m3.setAge(3);
m3.setCreateTime(DateUtil.parseDate("2019-01-2216:13:18"));
MySortBeanm4=newMySortBean();
m4.setAge(4);
m4.setCreateTime(DateUtil.parseDate("2019-01-2416:13:18"));
MySortBeanm5=newMySortBean();
m5.setAge(5);
m5.setCreateTime(DateUtil.parseDate("2019-01-2516:13:18"));
Listl=newArrayList<>(5);
l.add(m1);
l.add(m2);
l.add(m4);
l.add(m5);
l.add(m3);

System.out.println("排序前：");
for(MySortBeani:l){
System.out.println(DateUtil.formatDate(i.getCreateTime(),"yyyy-MM-ddHH:mm:ss"));
}
/**
*自定义排序
*直接return-1倒叙排列，list顺序颠倒输出
*
*if(o1.getAge()>o2.getAge()){
*return1;
*}
*return-1;
*以上升序输出
*
*if(o1.getAge()>o2.getAge()){
*return-1;
*}
*return1;
*以上降序输出
*
*
*/
/*Comparatorcomparator=newComparator(){
@Override
publicintcompare(MySortBeano1,MySortBeano2){
if(o1.getAge()>o2.getAge()){
return-1;
}
return1;
}
};
l.sort(comparator);*/
l.sort(MySortBean::compareTo);
System.out.println("--------");
System.out.println("排序后：");
for(MySortBeani:l){
System.out.println(DateUtil.formatDate(i.getCreateTime(),"yyyy-MM-ddHH:mm:ss"));
}
}
}

4.时间格式化工具类

packagecom.spring.testlist.util;
importorg.apache.commons.lang3.time.DateFormatUtils;
importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.Calendar;
importjava.util.Date;

/**
*日期工具类,继承org.apache.commons.lang.time.DateUtils类
*
*@authorcui
*@create2018-10-2615:30
**/
publicclassDateUtilextendsorg.apache.commons.lang3.time.DateUtils{

privatestaticString[]parsePatterns={
"yyyy-MM-dd","yyyy-MM-ddHH:mm:ss","yyyy-MM-ddHH:mm","yyyy-MM",
"yyyy/MM/dd","yyyy/MM/ddHH:mm:ss","yyyy/MM/ddHH:mm","yyyy/MM",
"yyyy.MM.dd","yyyy.MM.ddHH:mm:ss","yyyy.MM.ddHH:mm","yyyy.MM"};

/**
*得到当前日期字符串格式（yyyy-MM-dd）
*/
publicstaticStringgetDate(){
returngetDate("yyyy-MM-dd");
}
/**
*得到当前日期字符串格式（yyyyMMdd）
*/
publicstaticStringgetSizeDate(){
returngetDate("yyyyMMdd");
}

/**
*得到当前日期字符串格式（yyyy-MM-dd）pattern可以为："yyyy-MM-dd""HH:mm:ss""E"
*/
publicstaticStringgetDate(Stringpattern){
returnDateFormatUtils.format(newDate(),pattern);
}

/**
*得到日期字符串默认格式（yyyy-MM-dd）pattern可以为："yyyy-MM-dd""HH:mm:ss""E"
*/
publicstaticStringformatDate(Datedate,Object...pattern){
if(date==null){
returnnull;
}
StringformatDate=null;
if(pattern!=null&&pattern.length>0){
formatDate=DateFormatUtils.format(date,pattern[0].toString());
}else{
formatDate=DateFormatUtils.format(date,"yyyy-MM-dd");
}
returnformatDate;
}

/**
*得到日期时间字符串，转换格式（yyyy-MM-ddHH:mm:ss）
*/
publicstaticStringformatDateTime(Datedate){
returnformatDate(date,"yyyy-MM-ddHH:mm:ss");
}

/**
*得到当前时间字符串格式（HH:mm:ss）
*/
publicstaticStringgetTime(){
returnformatDate(newDate(),"HH:mm:ss");
}

/**
*得到当前日期和时间字符串格式（yyyy-MM-ddHH:mm:ss）
*/
publicstaticStringgetDateTime(){
returnformatDate(newDate(),"yyyy-MM-ddHH:mm:ss");
}

/**
*得到当前年份字符串格式（yyyy）
*/
publicstaticStringgetYear(){
returnformatDate(newDate(),"yyyy");
}

/**
*得到当前月份字符串格式（MM）
*/
publicstaticStringgetMonth(){
returnformatDate(newDate(),"MM");
}

/**
*得到当天字符串格式（dd）
*/
publicstaticStringgetDay(){
returnformatDate(newDate(),"dd");
}

/**
*得到当前星期字符串格式（E）星期几
*/
publicstaticStringgetWeek(){
returnformatDate(newDate(),"E");
}

/**
*日期型字符串转化为日期格式
*{"yyyy-MM-dd","yyyy-MM-ddHH:mm:ss","yyyy-MM-ddHH:mm",
*"yyyy/MM/dd","yyyy/MM/ddHH:mm:ss","yyyy/MM/ddHH:mm",
*"yyyy.MM.dd","yyyy.MM.ddHH:mm:ss","yyyy.MM.ddHH:mm"}
*/
publicstaticDateparseDate(Objectstr){
if(str==null){
returnnull;
}
try{
returnparseDate(str.toString(),parsePatterns);
}catch(ParseExceptione){
returnnull;
}
}
/**
*获取过去的天数
*
*@paramdate
*@return
*/
publicstaticlongpastDays(Datedate){

longt=System.currentTimeMillis()-date.getTime();
returnt/(24*60*60*1000);
}
/**
*获取过去的小时
*
*@paramdate
*@return
*/
publicstaticlongpastHour(Datedate){
longt=System.currentTimeMillis()-date.getTime();
returnt/(60*60*1000);
}
/**
*获取过去的分钟
*
*@paramdate
*@return
*/
publicstaticlongpastMinutes(Datedate){
longt=System.currentTimeMillis()-date.getTime();
returnt/(60*1000);
}
/**
*转换为时间（天,时:分:秒.毫秒）
*
*@paramtimeMillis
*@return
*/
publicstaticStringformatDateTime(longtimeMillis){
longday=timeMillis/(24*60*60*1000);
longhour=(timeMillis/(60*60*1000)-day*24);
longmin=((timeMillis/(60*1000))-day*24*60-hour*60);
longs=(timeMillis/1000-day*24*60*60-hour*60*60-min*60);
longsss=(timeMillis-day*24*60*60*1000-hour*60*60*1000-min*60*1000-s*1000);
return(day>0?day+",":"")+hour+":"+min+":"+s+"."+sss;
}
/**
*获取两个日期之间的天数
*
*@parambefore
*@paramafter
*@return
*/
publicstaticdoublegetDistanceOfTwoDate(Datebefore,Dateafter){
longbeforeTime=before.getTime();
longafterTime=after.getTime();
return(afterTime-beforeTime)/(1000*60*60*24);
}
publicstaticStringgetFirstDayOfMonth(){
SimpleDateFormatformat=newSimpleDateFormat("yyyy-MM-dd");
//获取当前月第一天：
Calendarc=Calendar.getInstance();
c.add(Calendar.MONTH,0);
c.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
Stringfirst=format.format(c.getTime());
returnfirst;
}
/**
*@paramargs
*@throwsParseException
*/
publicstaticvoidmain(String[]args)throwsParseException{
//System.out.println(formatDate(parseDate("2010/3/6")));
//System.out.println(getDate("yyyy年MM月dd日E"));
//longtime=newDate().getTime()-parseDate("2012-11-19").getTime();
//System.out.println(time/(24*60*60*1000));
StringsizeDate=formatDate(newDate(),"yyyyMMdd");
System.out.println(sizeDate);
}
}

到此就结束了，具体的要实现什么排序，根据示例自己脑补扩展就好了，例子中备注也已经标注。

在使用排序注意两个坑

1.要排序的字段为空的异常处理

2.要排序的字段相等的异常处理

补充知识：Java中的自然排序和比较器排序

写在前面的话：刚开始学习着两者排序时我也是一头雾水，虽然能写出来但是稀里糊涂，几时该用哪个排序一点想法都没有，后来经过研究这两者的作用点不同，自然排序作用在实体类上，而比较器排序作用在装实体类的集合上。

1、自然排序：java.lang.Comparable

Comparable接口中只提供了一个方法：compareTo(Objectobj)，该方法的返回值是int。如果返回值为正数，则表示当前对象(调用该方法的对象)比obj对象“大”；反之“小”；如果为零的话，则表示两对象相等。

总结为一句话：实现Comparable，重写compareTo方法

案列：以TreeMap为例，默认的升序，可以重写自然排序的方法改变原有排序

publicstaticvoidtestComparable(){
TreeMaptmp=newTreeMap();
tmp.put(newCar(4),"肆");
tmp.put(newCar(1),"壹");
tmp.put(newCar(5),"伍");
tmp.put(newCar(3),"三");
tmp.put(newCar(2),"贰");
System.out.println(tmp);
//结果：//{Car[price=5.0]=伍,Car[price=4.0]=肆,Car[price=3.0]=三,Car[price=2.0]=贰,Car[price=1.0]=壹}
}
//自定义TreeMap排序方法自然排序

classCarimplementsComparable{
privatedoubleprice;

publicdoublegetPrice(){
returnprice;
}

publicvoidsetPrice(doubleprice){
this.price=price;
}

publicCar(intprice){
super();
this.price=price;
}

@Override
publicintcompareTo(Caro){
//TODOAuto-generatedmethodstub
if(this.price>o.getPrice()){
return-1;//大的往前排
}elseif(this.price
2、比较器排序：java.util.Comparator
总结为一句话：实现Comparator接口，重写compare方法
publicstaticvoidtestComparator(){
//HashMaphm=newHashMap();
TreeMaptmp=newTreeMap(newMyComparatorBigtoSmall());
tmp.put(4,"肆");
tmp.put(1,"壹");
tmp.put(5,"伍");
tmp.put(3,"三");
tmp.put(2,"贰");
//System.out.println(tmp);//默认排序结果：{1=壹,2=贰,3=三,4=肆,5=伍}
System.out.println(tmp);//修改为比较器排序(升序){5=伍,4=肆,3=三,2=贰,1=壹}
}

//自定义TreeMap排序方法比较器排序
classMyComparatorBigtoSmallimplementsComparator{

@Override
publicintcompare(Integero1,Integero2){
//TODOAuto-generatedmethodstub
returno2-o1;
}
}
以上这篇java实现Comparable接口排序,升序、降序、倒叙就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

java 实现Comparable接口排序,升序、降序、倒叙

热门推荐

随机推荐