Collections
sort函数定义
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:"); System.out.println(Arrays.toString(intList.toArray())); System.out.println("========================="); Collections.sort(intList); System.out.println("after sort:"); System.out.println(Arrays.toString(intList.toArray())); } public static void main(String[] args) { leetcode.sortBaseTypeByDefaultMode(); }
运行结果如下：
第一种方法
可以看到，默认的排序是正序，那么如何实现逆序呢，这就要使⽤第⼆种⽅式了，即通过实现Comparator接⼝的compare⽅法来完成⾃定义排序，代码如下：
static List<Integer> intList = Arrays.asList(2, 3, 1); private static void sortBaseTypeByIDefineMode() { System.out.println("before sort:"); System.out.println(Arrays.toString(intList.toArray())); 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:"); System.out.println(Arrays.toString(intList.toArray())); } public static void main(String[] args) { // leetcode.sortBaseTypeByDefaultMode(); leetcode.sortBaseTypeByIDefineMode(); }
可以看到，已经实现了逆序的排序了。
⾃定义类的排序
接下来看看⾃定义类的排序：
定义⼀个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，使⽤sort⽅法的第⼆种形式：
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); } private static void sortEmpByIDefineMode() { System.out.println("before sort:"); System.out.println(Arrays.toString(empList.toArray())); 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:"); System.out.println(Arrays.toString(empList.toArray())); } public static void main(String[] args) { // leetcode.sortBaseTypeByDefaultMode(); // leetcode.sortBaseTypeByIDefineMode(); leetcode.sortEmpByIDefineMode(); }
运行结果如下：
那么使用第一种方式能不能行呢，答案是可以的，但是不是直接的使用sort，例如下面是要报错的：
Collections.sort(empList);
我们需要这样做：⾸先让Emp类继承Comparable接⼝并重写compareTo⽅法（为了和上⾯的排序⽅式区别开，此次按照员⼯姓名逆序排列）：
@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()); }
main函数中调用方法
private static void sortEmpByIDafaultMode() { System.out.println("before sort:"); System.out.println(Arrays.toString(empList.toArray())); System.out.println("========================="); Collections.sort(empList); System.out.println("after sort:"); System.out.println(Arrays.toString(empList.toArray())); } public static void main(String[] args) { // leetcode.sortBaseTypeByDefaultMode(); // leetcode.sortBaseTypeByIDefineMode(); // leetcode.sortEmpByIDefineMode(); leetcode.sortEmpByIDafaultMode(); }
运行结果如下：
总结：
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:"); System.out.println(Arrays.toString(empList.toArray())); 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:"); System.out.println(Arrays.toString(empList.toArray())); }
复写的compare⽅法定义的是按员⼯编号正序排序，在使⽤reversed翻转后结果如下：
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进⾏排序。
具体实现代码⽅法如下：
package com.leetcode.www; 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)); } } }
⾃定义⽐较器和测试类：
package com.leetcode.www; 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 PriceComparator().reversed()); // 根据价格排序 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); } } }
