Java基础——Collections.sort的两种用法排序详解

转载自https://www.cnblogs.com/yw0219/p/7222108.html?utm_source=itdadao&utm_medium=referral

Collections是一个工具类,sort是其中的静态方法,是用来对List类型进行排序的,它有两种参数形式:

    public static <T extends Comparable<? super T>> void sort(List<T> list) {
        list.sort(null);
    }
    public static <T> void sort(List<T> list, Comparator<? super T> c) {
        list.sort(c);
    }

首先使用基本类型(此处使用Integer)来演示第一个方法:

    static List<Integer> intList = Arrays.asList(2, 3, 1);

private static void sortBaseTypeByDefaultMode() {
        System.out.println("before sort:");
        PrintUtil.showList(intList);
        System.out.println("=========================");
        Collections.sort(intList);
        System.out.println("after sort:");
        PrintUtil.showList(intList);
    }

PrintUtil.showList是自定义的一个打印List类型的方法,此处只关心输出结果就行,如下:

可以看到,默认的排序是正序,那么如何实现逆序呢,这就要使用第二种方式了,即通过实现Comparator接口的compare方法来完成自定义排序,代码如下:


    private static void sortBaseTypeByIDefineMode() {
        System.out.println("before sort:");
        PrintUtil.showList(intList);
        System.out.println("=========================");
        Collections.sort(intList,new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                // 返回值为int类型,大于0表示正序,小于0表示逆序
                return o2-o1;
            }
        });
        System.out.println("after sort:");
        PrintUtil.showList(intList);
    }

可以看到,已经实现了逆序的排序了。

接下来看看自定义类的排序:

定义一个Emp类:


public class Emp{
    private int empno;
    private String ename;
    public int getEmpno() {
        return empno;
    }
    public void setEmpno(int empno) {
        this.empno = empno;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    
    public Emp(int empno, String ename) {
        super();
        this.empno = empno;
        this.ename = ename;
    }
    @Override
    public String toString()
    {
        return "empno:\t"+empno+"\tename:\t"+ename;
    }
}

首先使用同样的方式来使用Collections.sort方法:

  定义泛型违Emp类型的List:


    static List<Emp> empList;
    static 
    {
        Emp emp1 = new Emp(2,"Guan YunChang");
        Emp emp2 = new Emp(3,"Zhang Fei");
        Emp emp3 = new Emp(1,"Liu Bei");
        empList = Arrays.asList(emp1,emp2,emp3);
    }

对empList进行排序:

此时会报错:

The method sort(List<T>) in the type Collections is not applicable for the arguments (List<Emp>)

意思是参数类型为List<Emp>时,sort方法无法执行,原因是泛型没有继承Comparable接口,这种方式稍后再说,我们先使用sort方法的第二种形式:


    private static void sortEmpByIDefineMode()
    {
        System.out.println("before sort:");
        PrintUtil.showList(empList);
        System.out.println("=========================");
        Collections.sort(empList,new Comparator<Emp>() {

            @Override
            public int compare(Emp o1, Emp o2) {
                /*按员工编号正序排序*/
                return o1.getEmpno()-o2.getEmpno();
                /*按员工编号逆序排序*/
                //return o2.getEmpno()-o1.getEmpno();
                /*按员工姓名正序排序*/
                //return o1.getEname().compareTo(o2.getEname());
                /*按员工姓名逆序排序*/
                //return o2.getEname().compareTo(o1.getEname());
            }
        });
        System.out.println("after sort:");
        PrintUtil.showList(empList);
    }

 

运行结果: 

根据不同的排序方式即可呈现不同的结果。

接下来看看第一种形式的实现,首先让Emp类继承Comparable接口并重写compareTo方法(为了和上面的排序方式区别开,此次按照员工姓名逆序排列):


public class Emp implements Comparable<Emp>{

    /*属性、getter/setter方法、toString方法及构造方法略*/
    @Override
    public int compareTo(Emp emp) {
        /*按员工编号正序排序*/
        //return this.getEmpno()-emp.getEmpno();
        /*按员工编号逆序排序*/
        //return emp.getEmpno()-this.getEmpno();
        /*按员工姓名正序排序*/
        //return this.getEname().compareTo(emp.getEname());
        /*按员工姓名逆序排序*/
        return emp.getEname().compareTo(this.getEname());
    }
}    

使用Collections.sor方法的第一种形式实现:


    private static void sortEmpByDefaultMode()
    {
        System.out.println("before sort:");
        PrintUtil.showList(empList);
        System.out.println("=========================");
        Collections.sort(empList);
        System.out.println("after sort:");
        PrintUtil.showList(empList);
    }

运行结果:

 

 

总结:

1.对于String或Integer这些已经实现Comparable接口的类来说,可以直接使用Collections.sort方法传入list参数来实现默认方式(正序)排序;

2.如果不想使用默认方式(正序)排序,可以通过Collections.sort传入第二个参数类型为Comparator来自定义排序规则;

3.对于自定义类型(如本例子中的Emp),如果想使用Collections.sort的方式一进行排序,可以通过实现Comparable接口的compareTo方法来进行,如果不实现,则参考第2点;

4.jdk1.8的Comparator接口有很多新增方法,其中有个reversed()方法比较实用,是用来切换正序和逆序的,代码如下:


    private static void sortEmpByIDefineMode()
    {
        System.out.println("before sort:");
        PrintUtil.showList(empList);
        System.out.println("=========================");
        Comparator<Emp> comparator = new Comparator<Emp>() {

            @Override
            public int compare(Emp o1, Emp o2) {
                /*按员工编号正序排序*/
                return o1.getEmpno()-o2.getEmpno();
                /*按员工编号逆序排序*/
                //return o2.getEmpno()-o1.getEmpno();
                /*按员工姓名正序排序*/
                //return o1.getEname().compareTo(o2.getEname());
                /*按员工姓名逆序排序*/
                //return o2.getEname().compareTo(o1.getEname());
            }
            
        };
        
        /*新的逆序实现方式*/
        Collections.sort(empList,comparator.reversed());
        System.out.println("after sort:");
        PrintUtil.showList(empList);
    }

复写的compare方法定义的是按员工编号正序排序,在使用reversed翻转后结果如下:

这样就使得排序规则的切换更为方便了。

转载自http://blog.csdn.net/tjcyjd/article/details/6804690

Comparator是个接口,可重写compare()及equals()这两个方法,用于比价功能;如果是null的话,就是使用元素的默认顺序,如a,b,c,d,e,f,g,就是a,b,c,d,e,f,g这样,当然数字也是这样的。

compare(a,b)方法:根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
equals(obj)方法:仅当指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时才返回 true。

Collections.sort(list, new PriceComparator());的第二个参数返回一个int型的值,就相当于一个标志,告诉sort方法按什么顺序来对list进行排序。

具体实现代码方法如下:

Book实体类:

    package com.tjcyjd.comparator;  
      
    import java.text.DecimalFormat;  
    import java.text.SimpleDateFormat;  
    import java.util.GregorianCalendar;  
    import java.util.Iterator;  
    import java.util.TreeMap;  
      
    /** 
     * 书实体类 
     *  
     * @author yjd 
     *  
     */  
    public class Book implements Comparable { // 定义名为Book的类,默认继承自Object类  
        public int id;// 编号  
        public String name;// 名称  
        public double price; // 价格  
        private String author;// 作者  
        public GregorianCalendar calendar;// 出版日期  
      
        public Book() {  
            this(0, "X", 0.0, new GregorianCalendar(), "");  
        }  
      
        public Book(int id, String name, double price, GregorianCalendar calender,  
                String author) {  
            this.id = id;  
            this.name = name;  
            this.price = price;  
            this.calendar = calender;  
            this.author = author;  
        }  
      
        // 重写继承自父类Object的方法,满足Book类信息描述的要求  
        public String toString() {  
            String showStr = id + "\t" + name; // 定义显示类信息的字符串  
            DecimalFormat formatPrice = new DecimalFormat("0.00");// 格式化价格到小数点后两位  
            showStr += "\t" + formatPrice.format(price);// 格式化价格  
            showStr += "\t" + author;  
            SimpleDateFormat formatDate = new SimpleDateFormat("yyyy年MM月dd日");  
            showStr += "\t" + formatDate.format(calendar.getTime()); // 格式化时间  
            return showStr; // 返回类信息字符串  
        }  
      
        public int compareTo(Object obj) {// Comparable接口中的方法  
            Book b = (Book) obj;  
            return this.id - b.id; // 按书的id比较大小,用于默认排序  
        }  
      
        public static void main(String[] args) {  
            Book b1 = new Book(10000, "红楼梦", 150.86, new GregorianCalendar(2009,  
                    01, 25), "曹雪芹、高鄂");  
            Book b2 = new Book(10001, "三国演义", 99.68, new GregorianCalendar(2008, 7,  
                    8), "罗贯中 ");  
            Book b3 = new Book(10002, "水浒传", 100.8, new GregorianCalendar(2009, 6,  
                    28), "施耐庵 ");  
            Book b4 = new Book(10003, "西游记", 120.8, new GregorianCalendar(2011, 6,  
                    8), "吴承恩");  
            Book b5 = new Book(10004, "天龙八部", 10.4, new GregorianCalendar(2011, 9,  
                    23), "搜狐");  
            TreeMap tm = new TreeMap();  
            tm.put(b1, new Integer(255));  
            tm.put(b2, new Integer(122));  
            tm.put(b3, new Integer(688));  
            tm.put(b4, new Integer(453));  
            tm.put(b5, new Integer(40));  
            Iterator it = tm.keySet().iterator();  
            Object key = null, value = null;  
            Book bb = null;  
            while (it.hasNext()) {  
                key = it.next();  
                bb = (Book) key;  
                value = tm.get(key);  
                System.out.println(bb.toString() + "\t库存:" + tm.get(key));  
            }  
        }  
    }  

自定义比较器和测试类:

import java.util.ArrayList;  
import java.util.Collections;  
import java.util.Comparator;  
import java.util.GregorianCalendar;  
import java.util.Iterator;  
import java.util.List;  
  
public class UseComparator {  
    public static void main(String args[]) {  
        List<Book> list = new ArrayList<Book>(); // 数组序列  
        Book b1 = new Book(10000, "红楼梦", 150.86, new GregorianCalendar(2009,  
                01, 25), "曹雪芹、高鄂");  
        Book b2 = new Book(10001, "三国演义", 99.68, new GregorianCalendar(2008, 7,  
                8), "罗贯中 ");  
        Book b3 = new Book(10002, "水浒传", 100.8, new GregorianCalendar(2009, 6,  
                28), "施耐庵 ");  
        Book b4 = new Book(10003, "西游记", 120.8, new GregorianCalendar(2011, 6,  
                8), "吴承恩");  
        Book b5 = new Book(10004, "天龙八部", 10.4, new GregorianCalendar(2011, 9,  
                23), "搜狐");  
        list.add(b1);  
        list.add(b2);  
        list.add(b3);  
        list.add(b4);  
        list.add(b5);  
        // Collections.sort(list); //没有默认比较器,不能排序  
        System.out.println("数组序列中的元素:");  
        myprint(list);  
        Collections.sort(list, new PriceComparator()); // 根据价格排序  
        System.out.println("按书的价格排序:");  
        myprint(list);  
        Collections.sort(list, new CalendarComparator()); // 根据时间排序  
        System.out.println("按书的出版时间排序:");  
        myprint(list);  
    }  
  
    // 自定义方法:分行打印输出list中的元素  
    public static void myprint(List<Book> list) {  
        Iterator it = list.iterator(); // 得到迭代器,用于遍历list中的所有元素  
        while (it.hasNext()) {// 如果迭代器中有元素,则返回true  
            System.out.println("\t" + it.next());// 显示该元素  
        }  
    }  
  
    // 自定义比较器:按书的价格排序  
    static class PriceComparator implements Comparator {  
        public int compare(Object object1, Object object2) {// 实现接口中的方法  
            Book p1 = (Book) object1; // 强制转换  
            Book p2 = (Book) object2;  
            return new Double(p1.price).compareTo(new Double(p2.price));  
        }  
    }  
  
    // 自定义比较器:按书出版时间来排序  
    static class CalendarComparator implements Comparator {  
        public int compare(Object object1, Object object2) {// 实现接口中的方法  
            Book p1 = (Book) object1; // 强制转换  
            Book p2 = (Book) object2;  
            return p2.calendar.compareTo(p1.calendar);  
        }  
    }  
}  



相关推荐
©️2020 CSDN 皮肤主题: 像素格子 设计师:CSDN官方博客 返回首页