第十二章 比较器（1.5）

比较器 Comparable和Comparator

1、比较器的概念

比较器，顾名思义，是在比较的时候需要用到的一种工具。其最主要的作用是用来实现对象的比较逻辑，解决对象在需要排序的情况下孰先孰后这一问题。

2、Comparable接口

之前的内容中介绍了java.util.TreeSet类，了解到java.util.TreeSet集合在保存元素时会对元素进行比较并按照自然的方式对元素进行排序，并且演示了在一个java.util.TreeSet集合中存储多个java.lang.Integer类的对象后元素是怎样排序的，如果在java.util.TreeSet集合中存储多个自定义引用类型的对象，会怎样排序呢？

下面是一个示例：
Student类的源码：

package com.codeke.java.test;

public class Student {
private String name; // 姓名
private Integer mathScore; // 数学成绩
private Integer ChineseScore; // 语文成绩
// 构造方法
public Student(String name, Integer mathScore, Integer chineseScore) {
this.name = name;
this.mathScore = mathScore;
ChineseScore = chineseScore;
}
// 学习的方法
public void study(){
System.out.println(“student” + this.name + “在学习，数学成绩是”
+ this.mathScore + “,语文成绩是” + this.ChineseScore);
}
}
测试类Test类的源码：

package com.codeke.java.test;

import java.util.Set;
import java.util.TreeSet;

public class Test {
public static void main(String[] args) {
// 实例化几个Student对象
Student stu1 = new Student(“鲁智深”, 70, 75);
Student stu2 = new Student(“武松”, 73, 80);
Student stu3 = new Student(“林冲”, 76, 87);
Student stu4 = new Student(“吴用”, 95, 81);
Student stu5 = new Student(“公孙胜”, 90, 85);
// 声明变量treeSet，引用一个TreeSet实例
Set treeSet = new TreeSet();
treeSet.add(stu1);
treeSet.add(stu2);
treeSet.add(stu3);
treeSet.add(stu4);
treeSet.add(stu5);
// 遍历treeSet集合中的元素
for (Student stu : treeSet) {
stu.study();
}
}
}

执行输出结果：

Exception in thread “main” java.lang.ClassCastException: com.codeke.java.test.Student cannot be cast to java.lang.Comparable
at java.util.TreeMap.compare(TreeMap.java:1294)
at java.util.TreeMap.put(TreeMap.java:538)
at java.util.TreeSet.add(TreeSet.java:255)
at com.codeke.java.test10.Test.main(Test.java:16)

说明：

观察本例，当treeSet集合中添加自定义引用类型的对象时，抛出了ClassCastException异常，异常的信息中提示Student类的对象并不能转换成java.lang.Comparable接口类型。
实际上，java.util.TreeSet集合保证元素唯一，并且能够对元素进行排序，均是因为集合中的元素所属的类型实现了java.lang.Comparable接口。
下面介绍java.lang.Comparable接口，该接口是一个泛型接口，其中只声明了一个compareTo(T o)方法，方法的返回值类型为int，该方法可以由实现类自定义对象如何比较，当方法返回值大于0时，表示调用方法的对象比方法参数对象大，当方法返回值等于0时，表示调用方法的对象与方法参数对象相等，当方法返回值小于0时，表示调用方法的对象比方法参数对象小。

下面节选了java.lang.Integer类和java.lang.String类中的部分代码，可以看到这两个类均实现了java.lang.Comparable接口。
java.lang.Integer类是如何实现java.lang.Comparable接口的：

public final class Integer implements Comparable {
public int compareTo(Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
}

java.lang.String类是如何实现java.lang.Comparable接口的：

public final class String implements Comparable {
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;

    int k = 0;
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    return len1 - len2;
}

}

下面是另一个示例：
Student类修改后的源码：

package com.codeke.java.test;

public class Student implements Comparable{
private String name; // 姓名
private Integer mathScore; // 数学成绩
private Integer ChineseScore; // 语文成绩
// 构造方法
public Student(String name, Integer mathScore, Integer chineseScore) {
this.name = name;
this.mathScore = mathScore;
ChineseScore = chineseScore;
}
// 学习的方法
public void study(){
System.out.println(“student” + this.name + “在学习，数学成绩是”
+ this.mathScore + “,语文成绩是” + this.ChineseScore);
}
// 重写Comparable接口中的compareTo(T o)方法
@Override
public int compareTo(Student o) {
return name.compareTo(o.name);
}
}
测试类Test类的源码同上例。
执行输出结果：

student公孙胜在学习，数学成绩是90,语文成绩是85
student吴用在学习，数学成绩是95,语文成绩是81
student林冲在学习，数学成绩是76,语文成绩是87
student武松在学习，数学成绩是73,语文成绩是80
student鲁智深在学习，数学成绩是70,语文成绩是75
说明：

本例中Student类实现了java.lang.Comparable接口，并重写了compareTo(T o)方法，于是，集合treeSet中可以添加Student类的对象并对集合中的元素进行排序。

3、Comparator接口

对于java.lang.Comparable接口，一个类只能实现一次。但如果对某一类的若干实例需要使用不同的比较方式进行比较，比如上例中的若干个Student类对象，数学老师希望看到按数学成绩排序的结果，语文老师则希望看到按语文成绩排序的结果，此时，还需要用到实现了java.lang.Comparator接口的比较器。

java.lang.Comparator接口是一个泛型接口，其中声明compare(T o1, T o2)方法，该方法与java.lang.Comparable接口中的compareTo(T o)方法非常相似，方法的返回值类型也是int，比较逻辑也是相同的，不同的是，参与比较的两个对象均是通过方法参数传入的。

下面是一个示例：
Student类修改后的源码：

package com.codeke.java.test;

public class Student implements Comparable{
private String name; // 姓名
private Integer mathScore; // 数学成绩
private Integer ChineseScore; // 语文成绩
// 构造方法
public Student(String name, Integer mathScore, Integer chineseScore) {
this.name = name;
this.mathScore = mathScore;
ChineseScore = chineseScore;
}
// 学习的方法
public void study(){
System.out.println(“student” + this.name + “在学习，数学成绩是”
+ this.mathScore + “,语文成绩是” + this.ChineseScore);
}
// 重写Comparable接口中的compareTo(T o)方法
@Override
public int compareTo(Student o) {
return name.compareTo(o.name);
}
// 获取数学成绩
public Integer getMathScore() {
return mathScore;
}
// 获取语文成绩
public Integer getChineseScore() {
return ChineseScore;
}
}
测试类Test类修改后的源码：

package com.codeke.java.test;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class Test {
public static void main(String[] args) {
// 实例化几个Student对象
Student stu1 = new Student(“鲁智深”, 70, 75);
Student stu2 = new Student(“武松”, 73, 80);
Student stu3 = new Student(“林冲”, 76, 87);
Student stu4 = new Student(“吴用”, 95, 81);
Student stu5 = new Student(“公孙胜”, 90, 85);

    // 声明变量mathScoreTreeSet，引用一个TreeSet实例，构造方法传入一个实现了Comparator接口的比较器
    Set<Student> mathScoreTreeSet = new TreeSet<Student>(new Comparator<Student>() {
        @Override
        public int compare(Student s1, Student s2) {
            // 按数学成绩进行比较
            return s1.getMathScore().compareTo(s2.getMathScore());
        }
    });
    mathScoreTreeSet.add(stu1);
    mathScoreTreeSet.add(stu2);
    mathScoreTreeSet.add(stu3);
    mathScoreTreeSet.add(stu4);
    mathScoreTreeSet.add(stu5);
    // 遍历treeSet集合中的元素
    System.out.println("按数学成绩排序：");
    for (Student stu : mathScoreTreeSet) {
        stu.study();
    }

    // 声明变量chineseScoreTreeSet，引用一个TreeSet实例，构造方法传入一个实现了Comparator接口的比较器
    Set<Student> chineseScoreTreeSet = new TreeSet<Student>(new Comparator<Student>() {
        @Override
        public int compare(Student s1, Student s2) {
            // 按语文成绩进行比较
            return s1.getChineseScore().compareTo(s2.getChineseScore());
        }
    });
    chineseScoreTreeSet.add(stu1);
    chineseScoreTreeSet.add(stu2);
    chineseScoreTreeSet.add(stu3);
    chineseScoreTreeSet.add(stu4);
    chineseScoreTreeSet.add(stu5);
    // 遍历treeSet集合中的元素
    System.out.println("按语文成绩排序：");
    for (Student stu : chineseScoreTreeSet) {
        stu.study();
    }
}

}
说明：

本例中，实例化java.util.treeSet集合时，通过构造方法传入了不同的、实现了java.lang.Comparator接口的比较器，在实现比较器时还用到了匿名内部类。
通过比较本例和上例，可以看到两种比较器在使用方式上的不同。
需要注意的是，实现了java.lang.Comparator接口的比较器优先级较高，当同时存在分别实现了java.lang.Comparable接口和java.lang.Comparator接口的比较器时，会优先按照后者实现的比较逻辑进行比较。