在一般情况下SQL语句不好实现的排序

就使用List的父类Collection自带的排序功能以实现需求

代码如下，其中：

formInfoList：List集合对象

FormInfo：指定集合类对象
	// 排序
    Collections.sort(formInfoList, new Comparator<FormInfo>() {
      @Override
      public int compare(FormInfo o1, FormInfo o2) {
        //按类型排序
        int flag = o1.getType().compareTo(o2.getType());   //这是升降，前面为升序    o2.getName().compareTo(o1.getName()) ---》这是降序    （下面同理）
        //按标题排序
        if (flag == 0) {
          flag = o1.getFormName().compareTo(o2.getFormName());
        }
        //按部门排序
        if (flag == 0) {
          flag = o1.getDepartment().compareTo(o2.getDepartment());
        }
        //按员工编码排序
        if (flag == 0) {
          flag = o1.getEmployee().compareToIgnoreCase(o2.getEmployee());
        }
/*        //按工资排序
        if(flag==0) {
          flag=(int)(o1.getSal()-o2.getSal());
        }*/
        return flag;
      }
    });

最近有时间，就整理整理自己做过的项目~这是某医院的微信网页开发项目。

话不多说，进入正题

情景：现在有一个List，需要对病人每一次的体检记录（Quota）按照日期进行降序排序（即近期放在最前面）
而Collections的sort方法默认是升序排列，如果需要降序排列时就需要重写compare方法。
首先放出compare的注释
 * @param o1 the first object to be compared.
     * @param o2 the second object to be compared.
     * @return a negative integer, zero, or a positive integer as the
     *         first argument is less than, equal to, or greater than the
     *         second.
     * @throws NullPointerException if an argument is null and this
     *         comparator does not permit null arguments
     * @throws ClassCastException if the arguments' types prevent them from
     *         being compared by this comparator.
     */
    int compare(T o1, T o2);

也就是说默认o1和o2比较，如果o1-o2返回负数，则把o1放在o2前面。（升序）
Collections.sort(list, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;//注意这一行代码
            }
        });

可我现在要实现降序，那么思路应该是
Collections.sort(list, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;//注意这一行代码
            }
        });

解释完compare方法，下面是该情景解决方案：
    //按日期排序（降序）
    private void ListSort(List<Quota> list) {
        //Collections的sort方法默认是升序排列，如果需要降序排列时就需要重写compare方法
        Collections.sort(list, new Comparator<Quota>() {
            @Override
            public int compare(Quota o1, Quota o2) {
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                try {
                    //获取体检日期，并把其类型由String转成Date，便于比较。
                    Date dt1 = format.parse(o1.getDate());
                    Date dt2 = format.parse(o2.getDate());

                    //以下代码决定按日期降序排序，若将return“-1”与“1”互换，即可实现升序。
                    //getTime 方法返回一个整数值，这个整数代表了从 1970 年 1 月 1 日开始计算到 Date 对象中的时间之间的毫秒数。
                    if (dt1.getTime() > dt2.getTime()) {
                        return -1;
                    } else if (dt1.getTime() < dt2.getTime()) {
                        return 1;
                    } else {
                        return 0;
                    }

                } catch (Exception e) {
                    logger.info("日期排序出错："+e);
                }
                return 0;
            }
        });
    }

此外，还有一种实现方式：
list.sort(new Comparator<Student>() {
    @Override
    public int compare(Quota o1, Quota o2) {
         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                    //获取体检日期，并把其类型由String转成Date，便于比较。
                    Date dt1 = format.parse(o1.getDate());
                    Date dt2 = format.parse(o2.getDate());

                    //以下代码决定按日期降序排序，若将return“-1”与“1”互换，即可实现升序。
                    //getTime 方法返回一个整数值，这个整数代表了从 1970 年 1 月 1 日开始计算到 Date 对象中的时间之间的毫秒数。
                    if (dt1.getTime() > dt2.getTime()) {
                        return -1;
                    } else if (dt1.getTime() < dt2.getTime()) {
                        return 1;
                    } else {
                        return 0;
                    }
    }
});


以上便是全部过程，有啥问题，欢迎评论~~~(๑•ᴗ•๑)
觉得还不错可以点个赞哦~ 谢谢(๑•ᴗ•๑)

package com.stream;


import java.util.Comparator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<TestDto> dtoList=TestDto.getDtos();

        //根据TestDto对象的priority字段降序排序
        dtoList.sort(Comparator.comparing(TestDto::getPriority).reversed());
        //根据TestDto对象的sort字段升序排序
       // dtoList.sort(Comparator.comparing(TestDto::getSort));


        for (TestDto d:dtoList
             ) {
            System.out.println(d);
        }
    }
}

这篇文章主要介绍了Java8 Comparator排序方法实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java8 中 Comparator 接口提供了一些静态方法，可以方便于我们进行排序操作，下面通过例子讲解下如何使用
对整数列表排序(升序)
List list = Arrays.asList(1,4,2,6,8);
list.sort(Comparator.naturalOrder());
System.out.println(list);
对整数列表排序(降序)
List list = Arrays.asList(1,8);
list.sort(Comparator.reverSEOrder());
System.out.println(list);
根据对象属性(年龄)进行排序
public class Test {
public static void main(String[] args) {
List personList = new ArrayList<>();
personList.add(new Person("a",2));
personList.add(new Person("b",4));
personList.add(new Person("c",7));
// 升序
personList.sort(Comparator.comparingInt(Person::getAge));
// 降序
personList.sort(Comparator.comparingInt(Person::getAge).reversed());
System.out.println(personList);
}
public static class Person {
private String name;
private Integer age;
public Person(String name,Integer age) {
this.name = name;
this.age = age;
}
public Integer getAge() {
return age;
}
// ... toString 方法
}
}
根据对象属性(价格、速度)进行排序，需要注意的是，排序有先后之分，不同的顺序会导致不同的结果
public class Test {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(new Computer("xiaomi",4000,6));
list.add(new Computer("sony",5000,4));
list.add(new Computer("dell",5));
list.add(new Computer("mac",6000,8));
list.add(new Computer("micro",6));
// 先以价格(升序)、后再速度(升序)
list.sort(Comparator.comparingInt(Computer::getPrice).thenComparingInt(Computer::getSpeed));
// 先以速度(降序)、后再价格(升序)
list.sort(Comparator.comparingInt(Computer::getSpeed).reversed().thenComparingInt(Computer::getPrice));
// 先以价格(降序)、后再速度(降序)
list.sort(Comparator.comparingInt(Computer::getPrice).thenComparingInt(Computer::getSpeed).reversed());
System.out.println(list);
}
public static class Computer {
private String name;
private Integer price;
private Integer speed;
public Computer(String name,Integer price,Integer speed) {
this.name = name;
this.price = price;
this.speed = speed;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
public Integer getSpeed() {
return speed;
}
public void setSpeed(Integer speed) {
this.speed = speed;
}
// ... toString 方法
}
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。
总结
如果觉得编程之家网站内容还不错，欢迎将编程之家网站推荐给程序员好友。
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您喜欢交流学习经验，点击链接加入交流1群：1065694478(已满)交流2群：163560250