Java中Comparable和Comparator两接口区别总结

Java 中为我们提供了两种比较机制：Comparable 和 Comparator。
两个词的意思都是比较的意思，但实际又是 可比较的 和 比较器。
所以很是疑惑。。。

1. Comparable 自然排序比较

java.lang 
public interface Comparable {
    // 有且仅有 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 { // 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 {
    // 比较其两个参数。 
    int compare(T o1, T o2);
    // JDK1.8 之后增加了很多其他的静态方法...参见 API 文档
}

Comparator 则是在外部制定排序规则，然后作为排序策略参数传给某些类。
比如 Collections.sort(), Arrays.sort(), 或者一些内部有序的集合（比如 SortedSet，SortedMap 等）。

使用方式主要分三步：

1. 创建一个 Comparator 接口的实现类，并赋值给一个对象在 compare 方法中针对自定义类写排序规则；
2. 将 Comparator 对象作为参数传递给 排序类的某个方法；
3. 向排序类中添加 compare 方法中使用的自定义类。

public class TestComparator {
    public static void main(String[] args) {
        // 示例1：添加时遵循构造传入的 Comparator 的 compare 规则进行
        // 1.创建一个实现 Comparator 接口的对象
        Comparator comparator = new Comparator() {
            @Override
            public int compare(String object1, String object2) {
                // return 1: 长的被换到后面；-1: 短的被换到后面
                return object1.length() > object2.length() ? 1 : -1;
            }
        };

        // 2.将此对象作为形参传递给 TreeSet 的构造方法中
        TreeSet treeSet = new TreeSet(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 list1 = Arrays.asList("ccc", "ddd", "aaa", "bbb");
        list1.sort(new Comparator() {
            @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 比较规则进行比较。