Comparable比较器和Comparator比较器

1、Comparable比较器

在Arrays类中存在sort()排序方法，此方法可以直接对对象数组进行排序。

 public static void sort(Object[] a

根据元素的自然顺序对指定对象数组按升序进行排序。但前提是数组中的所有元素都必须实现 Comparable 接口，并覆写compareTo()方法指定对象排序的规则。

Comparable接口定义于java.lang包中：public interface Comparable<T>;int compareTo(T t)方法比较此对象与指定对象的顺序。

现在新建一个Student类，实现按照成绩的由高到低排序：

 import java.util.Arrays;

 class Student implements Comparable<Student> { //指定比较的类型也是Student
     private String name;
     private float score;
     public Student(String name,float score){
         this.name = name;
         this.score = score;
     }
     public String toString(){
         return "姓名： " + this.name + "\t"+"成绩： "+this.score;
     }
     @Override
     public int compareTo(Student o) {
         if(this.score>o.score)
             return 1;
         if(this.score<o.score)
             return -1;
         return 0;
     }
 }

 public class TestComparable {
     public static void main(String args[]){
         Student stus[] = {new Student("夏小宝",99.0f),
                 new Student("李花花",100.0f),new Student("陆小凤",90.0f),
                 new Student("李寻欢",88.5f)};
         Arrays.sort(stus);
         for (int i = 0; i < stus.length; i++) {
             System.out.println(stus[i]);
         }
     }
 }

若是Student类没有实现Comparable接口，则在使用Arrays.sort()方法时程序会出现 java.lang.ClassCastException异常。

2、Comparator比较器

如果一个类已经开发完成，但是在此类建立的初期并没有实现Comparable接口，此时肯定无法进行对象排序操作，所以为了解决这样的问题，Java又定义了另一个比较器的操作接口--Comparator接口。

 public interface Comparator<T>
 int compare(T o1, T o2) //比较用来排序的两个参数
 boolean equals(Object obj) //指示某个其他对象是否“等于”此 Comparator

新建一个学生类，要求按照成绩的由高到低进行排序。但在这个学生类中我们按照常规的定义，只是在其中覆写了Object类中的equals方法，不再实现Comparable接口。

 class Student{
     private String name;
     private float score;
     public Student(String name,float score){
         this.name = name;
         this.score = score;
     }
     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public float getScore() {
         return score;
     }

     public void setScore(float score) {
         this.score = score;
     }

     public String toString(){
         return "姓名： " + this.name + "\t"+"成绩： "+this.score;
     }
     public boolean equals(Object o){  //覆写Object类中的equals方法
         if(this == o){
             return true;
         }
         if(!(o instanceof Student)){
             return false;
         }
         Student stu = (Student)o;  //对Object类向下转型
         if(this.name.equals(stu.name)&&this.score == stu.score){
             return true;
         }else{
             return false;
         }
     }
 }

当然这样的类是不能进行对象排序的，为了让此类可以进行排序操作，所以需要单独为此类定义一个比较器，此比较器实现Comparator接口。应该注意的是这时调用sort方法时应该调用他的重载方法：

public static <T> void sort(T[] a,
                            Comparator<? super T> c)

 import java.util.Arrays;
 import java.util.Comparator;

 class StudentComparator implements Comparator<Student>{ //实现Comparator接口，指定比较类型为Student
     //Comparator接口存在compare和equals两个方法,但StudentComparator类中已经从Object类中继承了equals方法，不需要在覆写
     @Override
     public int compare(Student arg0, Student arg1) {
         if(arg0.getScore() == arg1.getScore()){
             return 0;
         }
         if(arg0.getScore() > arg1.getScore()){
             return 1;
         }else{
             return -1;
         }
     }
 }

 public class TestComparator {
     public static void main(String args[]){
         Student stus[] = {new Student("夏小宝",99.0f),
                 new Student("李花花",100.0f),new Student("陆小凤",90.0f),
                 new Student("李寻欢",88.5f)};
         Arrays.sort(stus,new StudentComparator());
         for (int i = 0; i < stus.length; i++) {
             System.out.println(stus[i]);
         }
     }
 }

可以看到，Comparable比较器是在需要比较的类在定义时就要实现。而如果一个类已经定义好，但我们又不想修改类的定义或修改起来比较麻烦，我们就为此类单独定义一个比较器，这个比较器实现Comparator接口。这是这两个接口的区别。