我们通常使用Collections.sort()方法来对一个简单的数据列表排序。但是当ArrayList是由自定义对象组成的，就需要使用comparable或者comparator接口了。在使用这两者进行排序之前，先尝试不实现任何接口来进行排序。
考虑下面的例子——有一个Student类，具有三个属性：name, rollno, age
public class Student {
private String name;
private int rollno;
private int age;
/* 有参构造 ...*/
/* getter and setter ...*/
}
然后需要一个Student组成的ArrayList：
import java.util.*;
public class ArrayListSorting { public static void main(String args[]){
ArrayList<Student> arraylist = new ArrayList<Student>();
arraylist.add(new Student(223, "Chaitanya", 26));
arraylist.add(new Student(245, "Rahul", 24));
arraylist.add(new Student(209, "Ajeet", 32)); Collections.sort(arraylist); for(Student str: arraylist){
System.out.println(str);
}
}
}
这里尝试去调用Collections.sort()方法，但是出错了：
Exception in thread “main” java.lang.Error: Unresolved compilation problem:
Bound mismatch: The generic method sort(List) of type Collections is not applicable for the arguments (ArrayList). The inferred type Student is not a valid substitute for the bounded parameter > at beginnersbook.com.Details.main(Details.java:11)
原因：对于排序的ArrayList，除非其中元素实现了Comparable或者Comparator接口，否则不能调用Collections.sort方法。
使用Comparable对ArrayList<Object>进行排序
我们想要根据age对Student进行排序——实现Comparable接口，重写compareTo方法。
package beginnersbook.com;
public class Student implements Comparable {
private String name;
private int rollno;
private int age;
/* 有参构造 */
...
//getter and setter methods
...
@Override
public int compareTo(Student comparestu) {
int compareAge=((Student)comparestu).getAge();
/* 正序排列 */
return this.age-compareAge;
/* 逆序排列 */
//return compareAge-this.age;
}
@Override
public String toString() {
return "[ rollno=" + rollno + ", name=" + name + ", age=" + age + "]";
}
}
现在我们可以正常调用Collections.sort方法了。
既然Comparable完成了我们的工作，为什么还需要Comparator呢？
使用Comparable接口我们只能根据一个属性对ArrayList进行排序。为了让排序可以根据多个属性进行，需要使用Comparator。
使用Comparator对ArrayList<Object>进行排序（多个属性）
重写Comparator的compare方法：
import java.util.Comparator;
public class Student {
private String name;
private int rollno;
private int age; /* 有参构造 */
...
//Getter and setter methods
...
/* 根据name进行排序 */
public static Comparator<Student> NameComparator = new Comparator<Student>() { public int compare(Student s1, Student s2) {
String name1 = s1.getName().toUpperCase();
String name2 = s2.getName().toUpperCase(); // 正序排列
return StudentName1.compareTo(StudentName2); // 逆序排列
//return StudentName2.compareTo(StudentName1);
}}; /* 根据rollno进行排序 */
public static Comparator<Student> StuRollno = new Comparator<Student>() { public int compare(Student s1, Student s2) { int rollno1 = s1.getRollno();
int rollno2 = s2.getRollno(); /* 正序排列 */
return rollno1-rollno2; /* 逆序排列 */
//return rollno2-rollno1;
}};
@Override
public String toString() {
return "[ rollno=" + rollno + ", name=" + name + ", age=" + age + "]";
} }
这样，我们就既可以用name进行排序，也可以用age进行排序，只需要在有不同的排序需求时，使用不同的Comparator就可以了（e.g. Collections.sort(arraylist, Student.NameComparator)）。
——以上内容译自Java ArrayList of Object Sort Example (Comparable And Comparator)
多属性组合排序
上面对Java的ArrayList自定义排序进行了基本介绍，下面是工作中遇到的一个需求：
对于一个漏洞，有两个排序依据，首先根据是否修复来排序，其次按照严重程度排序，类似于SQL中的ORDER BY field1, field2，若field1相同，则比较field2
可以看到，右边的一列是按照未修复，已修复的顺序排列的，而左边也是按照风险程度由高到低排列，但是分别对应了是否修复的顺序。这种排序可以认为也是多属性排序，但是与上边讲到的多属性不同，这种方式是多种属性结合的排序方式，
public static Comparator<Loopholes> loopholesComparator = new Comparator<Loopholes>() {
@Override
public int compare(Loopholes l1, Loopholes l2) {
Integer riskLevel1 = l1.getRiskLevel();
Integer riskLevel2 = l2.getRiskLevel();
Integer fixed1 = l1.getFixed();
Integer fixed2 = l2.getFixed();
int fixedComp = fixed1.compareTo(fixed2);
if (fixedComp != 0) {
return fixedComp;
} else {
return riskLevel1.compareTo(riskLevel2);
}
}
};
首先用fixed1与fixed2进行比较，若两者不相等，则直接排序，若两者相等（即compartTo返回0），继续比较风险等级并返回风险等级的排序结果。