精华内容
下载资源
问答
  • 就使用List的父类Collection自带的排序功能以实现需求 代码如下 // 排序 Collections.sort(formInfoList, new Comparator<FormInfo>() { @Override public int compare(FormInfo o1, FormInfo o2) { //按...

    在一般情况下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;
                        }
        }
    });
    
    

    以上便是全部过程,有啥问题,欢迎评论~~~(๑•ᴗ•๑)

    觉得还不错可以点个赞哦~ 谢谢(๑•ᴗ•๑)

    展开全文
  • Collections.sort(list, new Comparator(){ /* * int compare(Student o1, Student o2) 返回一个基本类型整型, * 返回负数表示:o1 小于o2, * 返回0 表示:o1和o2相等, * 返回正数表示:o1大于o2...
  • import java.util.Comparator; import java.util.List; public class Test { public static void main(String[] args) { List<... //根据TestDto对象priority字段降序排序 dtoList.sort(Co
    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 接口提供了一些静态方法,可以方便于我们进行排序操作,下面通过例子讲解下如何使用对整数列表排序(升序)List list = Arrays....

    这篇文章主要介绍了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

    展开全文
  • java 自定义排序【Comparator升序降序的记法】

    万次阅读 多人点赞 2017-12-25 18:57:26
    环境java: 1.7需求今天在写排序时,忘了是返回1,是正序,还是-1为正序。 或者说,正序或者降序我应该如何返回。例子说明Collections.sort(companyList, new Comparator() { @Override public int compare...
  • 利用Collections类 java.util.Collections.sort(java.util.List, java.util.Comparator) 方法,自定义比较器对象对指定对象进行排序对学生对象按照其 分数(降序)进行排序,当分数相同时按学号(从小到大)排序,代码...
  • java8 list.sort 排序

    2020-09-10 11:17:46
    // 按照List中对象id属性降序 list.sort(Comparator.comparing(User::getId).reversed()); // 多个条件升序 list.sort(Comparator.comparing(User::getId).thenComparing(User::getDeId)); // id升序,...
  • 本文旨在通过重写Comparator接口compare()方法实现对List的升序、降序、倒序排序。 首先明确一点: compare(Integer o1, Integer o2){}中,o1代表List容器中后一个元素,o2代表List容器中前一个元素...
  • java8List.sort()排序功能

    万次阅读 2019-08-29 10:54:35
    //按照List中对象id属性升序 ...//按照List中对象id属性降序 list.sort(Comparator.comparing(Stu::getId).reversed()); //多条件升序 list.sort(Comparator.comparing(Stu::getId).thenCompari...
  • java 8 list排序

    2020-04-19 23:40:36
    现在使用到的排序降序排序 Collections.sort(companyList, (a, b) -> b.getCreateTime().compareTo(a.getCreateTime())); 参考链接 https://blog.csdn.net/duyusean/article/details/81638333 ...
  • //根据Dict对象的sort字段降序排序 dictList.sort(Comparator.comparing(Dict::getSort).reversed()); //根据Dict对象的sort字段升序排序 dictList.sort(Comparator.comparing(Dict::getSort));
  • 使用Collections工具类进行排序Collections支付三种排序A.sort()默认排序(从小到大)B.reverse()倒序(从大到小)C.shuffle()随机排序List排序大体上分为如下两类:1、List 对Integer、String等类型的List排序2、List ...
  • JAVA 集合 升序|降序|随机|去重排序

    千次阅读 2018-04-28 14:03:10
    一、说明 List排序规则可分为如下: 1.自定义排序 2.使用Collections工具类进行排序  Collections支付三种排序 ...A.sort()默认排序(从小到大) ...1、List 对Integer、String等类型的List排序 2、Li
  • 上面转载文章是没谈到double的降序问题 重写之后,只有compareto 支持double类型比较 默认是升序 List<Map.Entry<Accommodation, Double>> list = new ArrayList<Map.Entry<Accommodation, ...
  • 功能:list元素为Person类型,需要根据listage属性升序排列,如果age属性值相同则保持list原有顺序  如果需要降序,修改demo2中return代码 为如下代码即可  return o2.getAge() - o1.getAge();...
  • 常见数据类型List直接把需要排序的list当做参数调用下列方法即可Collections.sort(list);//升序排列 Collections.sort(list,Collections.reverseOrder());//降序排列对象List举例:Student.java(一个简单的实体类)...
  • 对一个集合中对象进行排序,根据对象某个指标大小进行升序或降序排序。代码如下: // 进行降序排列 Collections.sort(list, new Comparator<ResultTypeDesc>() { public int compare...
  • /** * 降序升序 * * @param str * @since 0.0.1 */ public void sort(String str){ String[] nums = str.split(" "); List<Integer> odd = new Ar...
  • Java List排序

    2013-10-17 13:38:23
    实现:利用Collections类 sort(List list,Comparator c) 方法,自定义比较器对象对指定对象进行排序 代码实现 Student类 class Student{ private int id; private String name; privat
  • 一个list中存放了Student对象n个 现对listStudent对象进行排序 要求:班级升序,如果班级相同 按照学号降序排列 ! 我现在用Collections.sort实现了,在测试中没有问题 但是,在实际插入数据排序的时候 开始...
  • 本文转载地址:... 对一个集合中对象进行排序,根据对象某个指标大小进行升序或降序排序。代码如下: // 进行降序排列 Collections.sort(list, new Comparator<ResultTypeDesc>() { ...

空空如也

空空如也

1 2 3 4 5 6
收藏数 105
精华内容 42
关键字:

java的list排序sort降序

java 订阅