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接口。这是这两个接口的区别。