Java 中为我们提供了两种比较机制：Comparable 和 Comparator。
两个词的意思都是比较的意思，但实际又是 可比较的 和 比较器。
所以很是疑惑。。。
1. Comparable 自然排序比较
java.lang
public interface Comparable<T> {
// 有且仅有 1 个公开抽象方法
// 将此对象与指定的对象进行比较，返回正数、负数、0。
int compareTo(T o)
}
Comparable 可以让实现它的类的对象进行比较，具体的比较规则是按照 compareTo 方法中的规则进行，为 自然顺序比较。
compareTo 方法的返回值有 3 种情况：
正数 - 集合升序：e1.compareTo(e2) > 0 即 e1 > e2
零值 - 集合不变：e1.compareTo(e2) = 0 即 e1 = e2
负数 - 集合降序：e1.compareTo(e2) < 0 即 e1 < e2
自己定义的类如果想要使用有序的集合类，需要实现 Comparable 接口。
自己定义的类还需重写 equlas(), hashCode() 方法，为了保证类的对象比较的一致性。
代码示例：
public class TestComparable {
public static void main(String[] args) {
Teacher[] ts = new Teacher[] {
new Teacher("eric", 30),
new Teacher("abby", 29),
new Teacher("john", 22),
new Teacher("sani", 33), };
// Java中已有的接口、工具类，回调了现在写的 compareTo(Object o) 函数
java.util.Arrays.sort(ts); // 调用工具
for (Teacher teacher : ts) {
System.out.println(teacher.toString());
}
}
}
class Teacher implements Comparable<Teacher> { // java.lang.Comparable
String name;
int age;
public Teacher(String name, int age) {
super();
this.name = name;
this.age = age;
}
// 需要根据接口进行抽象方法覆盖 - 参考JDK1.8手册
@Override
public int compareTo(Teacher o) {
if (this.age > o.age) {
return 1;
} else if (this.age < o.age) {
return -1;
}
return 0;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Teacher other = (Teacher) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Teacher [name=" + name + ", age=" + age + "]";
}
}
输出：
Comparable
2. Comparator 定制排序比较
java.util
@FunctionalInterface // 函数式接口
public interface Comparator<T> {
// 比较其两个参数。
int compare(T o1, T o2);
// JDK1.8 之后增加了很多其他的静态方法...参见 API 文档
}
Comparator 则是在外部制定排序规则，然后作为排序策略参数传给某些类。
比如 Collections.sort(), Arrays.sort(), 或者一些内部有序的集合（比如 SortedSet，SortedMap 等）。
使用方式主要分三步：
- 创建一个 Comparator 接口的实现类，并赋值给一个对象在 compare 方法中针对自定义类写排序规则；
- 将 Comparator 对象作为参数传递给 排序类的某个方法；
- 向排序类中添加 compare 方法中使用的自定义类。
public class TestComparator {
public static void main(String[] args) {
// 示例1：添加时遵循构造传入的 Comparator 的 compare 规则进行
// 1.创建一个实现 Comparator 接口的对象
Comparator<String> comparator = new Comparator<String>() {
@Override
public int compare(String object1, String object2) {
// return 1: 长的被换到后面；-1: 短的被换到后面
return object1.length() > object2.length() ? 1 : -1;
}
};
// 2.将此对象作为形参传递给 TreeSet 的构造方法中
TreeSet<String> treeSet = new TreeSet<String>(comparator);
// 3.向 TreeSet 中添加 步骤 1 中 compare 方法中设计的类的对象
treeSet.add(new String("a"));
treeSet.add(new String("bbb"));
treeSet.add(new String("ccccc"));
treeSet.add(new String("dd"));
System.out.println(treeSet.toString()); // [a, dd, bbb, ccccc]
// 示例2：排序时遵循 Comparator 的 compare 规则，首字母大小
List<String> list1 = Arrays.asList("ccc", "ddd", "aaa", "bbb");
list1.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
// 按首字符排序规则，return 1:首字母大的换到后面; -1:首字母小的换到后面
return o1.charAt(0) > o2.charAt(0) ? 1 : -1;
}
});
System.out.println(list1); // [aaa, bbb, ccc, ddd]
}
}
输出结果：
输出结果
3. 两者的比较总结
对于已定义好的普通包装数据类型（比如 String, Integer, Double…），它们默认实现了Comparable 接口，实现了 compareTo 方法，我们可以直接使用。
而对于我们自定义的类，它们可能在不同情况下需要实现不同的比较策略，我们可以新创建 Comparator 接口，然后实现特定的 compare 比较规则进行比较。
