精华内容
下载资源
问答
  • Javasort实现降序排序

    万次阅读 2019-03-17 14:07:00
    Javasort实现降序排序 利用Collections的reverseOrder方法: import java.util.Arrays; import java.util.Collections; public class Main { public static void main(String[] args) { ...

    Java中sort实现降序排序

    利用Collections的reverseOrder方法:

    import java.util.Arrays;
    import java.util.Collections;
    
    public class Main {
        public static void main(String[] args) {
            Integer[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
            Arrays.sort(arr, Collections.reverseOrder());
            for (Integer x : arr) {
                System.out.print(x + " ");
            }
            System.out.println();
        }
    }

    利用Comparator接口复写compare方法:

    import java.util.Arrays;
    import java.util.Comparator;
    
    public class Main {
        public static void main(String[] args) {
            //注意,要想改变默认的排列顺序,不能使用基本类型(int,double, char),而要使用它们对应的类
            Integer[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
            //定义一个自定义类MyComparator的对象
            Comparator cmp = new MyComparator();
            Arrays.sort(arr, cmp);
            for (int x : arr) {
                System.out.print(x + " ");
            }
        }
    }
    
    //实现Comparator接口
    class MyComparator implements Comparator<Integer> {
        @Override //作用是检查下面的方法名是不是父类中所有的,也起到注释的作用
        public int compare(Integer a, Integer b) {
            return a > b ? -1 : 1;
        }
    }
    posted @ 2019-03-17 14:07 Youpeng 阅读( ...) 评论( ...) 编辑 收藏
    展开全文
  • I'm playing around with arrays and enums and i was wondering whats the most effect way to create a Comparator class to sort these dates in descending order. Heres my code.public enum Month {JAN(1), FE...

    I'm playing around with arrays and enums and i was wondering whats the most effect way to create a Comparator class to sort these dates in descending order. Heres my code.

    public enum Month {JAN(1), FEB(2), MAR(3), APR(4), MAY(5), JUN(6), JUL(7),

    AUG(8), SEPT(9), OCT(10), NOV(11), DEC(12);

    final int monthBoundary;

    Month(int y){

    monthBoundary=y;}

    }

    public enum Date {FIRST(1), SECOND(2), THIRD(3), FORTH(4),

    FIFTH(5)... THIRTYFIRST(31);

    final int dateBoundary;

    Date(int z){

    dateBoundary=z;}

    }

    //constructor etc here

    private static final List calendar = new ArrayList();

    static {

    for (Month month : Month.values()) {

    for (Date date : Date.values()) {

    calendar.add(new Cal(date, month));

    }

    }

    }

    //creates new calendar dates

    public static ArrayList newCal() {

    return new ArrayList(calendar);

    }

    Using the following statement i can print the array in the order its created.

    System.out.print(Card.calendar());

    How do you create a Comparator class to sort these dates in descending order?

    Ideally i would like it to sort the array whether it was already in order or in a random order.

    At this stage i am not concerned about dates that do not exist (e.g. Feb 31st) as i'm merely practising and self studying... Just trying to get the concept :)

    Thanks.

    ADDED:

    public ArrayList sortDescending(ArrayList calList){

    Comparator c = Collections.reverseOrder();

    Collections.sort(calList, c);

    return calList;

    }

    解决方案

    Collections.sort(list, new Comparator() {

    @Override

    public int compare(Cal cal1, Cal cal2) {

    int result = -cal1.getMonth().compareTo(cal2.getMonth()));

    if (result == 0) {

    result = -cal1.getDate().compareTo(cal2.getDate()));

    }

    return result;

    }

    });

    展开全文
  • 就使用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;
                        }
        }
    });
    
    

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

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

    展开全文
  • Java 使用Collections.reverse对list集合进行降序排序

    万次阅读 多人点赞 2017-09-25 17:15:11
    今天无意中搜了一下Collections.reverse这个方法,结果发现有些人...确实,使用Collections.reverse结合一定方法可以实现对list集合降序排序,但是直接使用Collections.reverse(list)这种方式来降序是错误的。 reverse
  • java List 排序 Collections.sort() 对 List 排序 //一个POJO例子class User { String name; String age; public User(String name,String age){ this.name=n
  • 不多说,记住2点, 直接上代码(下面是降序): package mall; ...import java.util.ArrayList;...import java.util.Collections;...import java.util.List; public class TestSort2 { public ...
  • JAVA 集合 升序|降序|随机|去重排序

    千次阅读 2018-04-28 14:03:10
    List排序规则可分为如下: 1.自定义排序 2.使用Collections工具类进行排序  Collections支付三种排序 A.sort()默认排序(从小到大) B.reverse()倒序(从大到小) C.shuffle()随机排序 List排序大体上分为...
  • 你可以对用户定义的类进行降序排序,这样覆盖compare()方法,Collections.sort(unsortedList,new Comparator() {@Overridepublic int compare(Person a, Person b) {return b.getName().compareTo(a.getName());...
  • 如有错误请指点。 自定义排序: 如果想要自定义排序, 就要重写Comparator...对于数组的降序排序代码 import java.util.Scanner; import java.util.Arrays; import java.util.Comparator; import java.util.List;...
  • struts2中sort标签默认是按升序排列的,如果想按降序排列按照以下方法即可。  &lt;s:bean id="myComparator" name="com.tfyy.yx.util.system.MyComparator"&gt;&lt;/s:bean&gt...
  • java List.sort排序功能

    2021-04-23 11:41:59
    //按照List中对象的id属性升序 list.sort(Comparator.comparing(Stu::getId)) //按照List中对象的id属性降序 list.sort(Comparator.comparing(Stu::getId).reversed()); //多条件升序 list.sort(Comp
  • 第一种方法: 类直接实现Comparator类 重写compareTo...Collections.sort(sortData, new Comparator&lt;MarketRankBean.BodyBean&gt;() { @Override public int compare(MarketRankBean.BodyBean o1, Mark...
  • /** * 降序 * 根据list集合中ConfigDistribution对象的count属性 */ private List<... listSort(List<ConfigDistribution> list) { Collections.sort(list, new Comparator<ConfigDistri...
  • 1.sort排序: public static void main(String[] args) { int[] arr={6,3,8,2,9,1,33,22,12,78}; Arrays.sort(arr); for (int i = 0; i < arr.length; i++) { System.out.print( arr[i]+" "); ...
  • java List根据元素进行升序降序排序

    千次阅读 2019-03-28 10:02:24
    首先实体类需要实现Comparable接口 实现compareTo()方法 ...然后调用Collections.sort(list); public static void main(String[] args) { List<Student> list=new ArrayList<Student>...
  • Java List 排序方法sort的使用详解

    千次阅读 2018-09-07 09:50:18
    对数组的排序: 1 2 3 4 5 6 7 8 //对数组排序 public void arraySort(){ ...  Arrays.sort(arr);//使用java.util.Arrays对象的sort方法 ...
  • Java里的数组降序

    千次阅读 2019-04-13 10:43:00
    Java升序容易,降序不易。 基本类型不能降序,至少要是包装类。 升序使用Arrays.sort() 降序要么使用Collections.reverse,要么实现Comparator接口 import java.util.Arrays;...import java.util.List;...
  • I'm trying to sort the list in descending order using Comparator Interface. But the values are not sorted in descending order. Not sure what i'm doing wrong here.public class Student {int rollNo;Strin...
  • list升序,降序,逆序 List list =new ArrayList(); //如果list是 5 7 2 6 8 1 4 1、升序: Collections.sort(list) //list: 1 2 4 5 6 7 8 2、降序: Collections.sort(list,Collections.reverseOrder())//...
  • java List sort 排序

    2017-03-18 14:36:42
    通过Collections.sort 排序 如按日期降序List, Object>> result = new ArrayList(); Collections.sort(result, new Comparator() { @Override public int compare(Object o1, Object o2) {

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,562
精华内容 7,824
关键字:

java的list排序sort降序

java 订阅