Java 中 Comparable 和 Comparator 接口及其简单应用（一）

Comparable 接口

我们常常看到这样一句话

Arrays 类中的 sort 方法承诺可以对对象数组进行排序，但要求满足下列条件：对象所属的类必须实现 Comparable 接口，重写 compareTo 方法

Comparable 代码如下：

public interface Comparable<T> {
    int compareTo(Object other);
}

　　比如在自己定义的 Employee 类中，对两个 Employee 实例， 想要根据各自的工资属性进行比较，则可以让 Employee 实现 Comparable 接口，并重写 compareTo 方法：

public int compareTo(Object otherObject){
    Employee other = (Employee) otherObject;
    return Double.compare(salary,  other.salary);
    // return this.salary - other.salary;
}

　　这里，使用了静态 Double.compare 方法，如果第一个参数小于第二个参数，会返回负值；如果二者相等，会返回0；否则，返回一个正值。也可以使用注释掉的方式。

　　通过在 Employee 类中实现 Comparable 接口，并重写 compareTo 方法，Employee 类的实例变量就可以通过 salary 属性进行比较了。比如有一个 Employee 的数组，可以通过

Employee[] employees = new Employee[5];// 并添加实例
Arrays.sort(employees);

对 employees 数组进行升序排序，如果想要按照 salary 降序排序，只需要将 compareTo 改为

public int compareTo(Object otherObject){
2     Employee other = (Employee) otherObject;
3     return Double.compare(other.salary,  salary);
4     // return  other.salary - this.salary;
5 }

那么如果是一个 String 类型的数组呢？如果直接调用

Arrays.sort()

　　则是默认按照字典序进行排序的，因为 String 类自己实现过 Compareble<String> 接口，按照字典序进行比较。现在假设我们需要按照字符串长度对字符串进行比较，总不能去更改 String 的源码吧！况且 String 也不让我们改。为了处理这种情况，Arrays.sort() 还有第二个版本，让我们自己传入一个比较器进行比较，这个比较器就是实现了 Comparator 接口的实例。

Comparator 接口

public interface Comparator<T> {
    int compare(T first, T second);
}

如果要按照字符串长度进行比较，可以先声明一个一个实现了 Comparator 接口的比较类：

class LenComparator implements Comparator<String> {
    public int compare(String first, String second) {
        return first.length() - second.length();
    }
}

再利用 Arrays.sort 进行排序

Arrays.sort(strs, new LenComparator());

也可以写成内部类的形式，比如下面对于字符串可变数组的排序：

public static void sortStrings() {
        String[] strs = new String[4];
        strs[0] = "dwefrwf";
        strs[1] = "12w";
        strs[2] = "w212";
        strs[3] = "1we2rwqw2re1e2";

        List<String> strings = new ArrayList<>(Arrays.asList(strs));

        Collections.sort(strings, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });

        for (String s : strings) {
            System.out.print(s + " ");
        }
    }

输出为

12w w212 dwefrwf 1we2rwqw2re1e2 

总结

　　总结一点，如果对于我们自己创建的 class 类，需要对其实例进行按照某种规则比较，则应该让其类实现 Comparable 接口，并重写 compareTo 方法；如果是调用的别人的类，且不能轻易更改这个类的源码，或者想要按照新的比较方式对两个实例进行比较，就需要根据 Comparator 接口自己定义比较器了。

Map 按照 key 进行排序

　　之前在写程序的过程中，经常会遇到想要对映射中的键值对按照 键 或者 值 进行比较排序，如果想要按照 key 进行升序排序，Java 为我们提供了 TreeMap，底层采用红黑树(一种效率更高应用更广的二叉搜索树)，按照 key 升序排列的有序映射。但是如果我们想要按照 key 降序排列呢，就得在声明 TreeMap 的时候为其指定比较器。比如下面一个方法，对给定数组，要统计数组中每个元素出现的次数，并且按照元素值降序排列。可以先声明一个 TreeMap 映射，为其注入按照 key 进行比较的比较器实例，这里使用的也是内部类的方式将实例注入进去，与上面的声明实例的方式有些许区别。

 public static void orderByKey(int[] nums) {
        Map<Integer, Integer> map = new TreeMap<>(
                new Comparator<Integer>() {
                    public int compare(Integer obj1, Integer obj2) {
                        // 按照 key 降序排序
                        //return obj2.compareTo(obj1);
                        return obj2 - obj1;
                        // 按照 key 升序排序，TreeMap 默认的排列方式
                        // return obj1.compareTo(obj2);
                    }
                }
        );

        for (int i=0; i<nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }                

然后测试一把

        int[] nums = {4,1,-1,2,-1,2,3};
         orderByKey(nums);

输出

4 : 1
3 : 1
2 : 2
1 : 1
-1 : 2

可以看到所得到的映射是按照 key 降序排序输出的。

Map 按照 value 进行排序

　　如果要将映射里的内容按照 value 进行排序呢？该如何操作，这里不能直接在声明 Map 的时候为其注入比较器实例，因为按照 value 进行比较，map 都还没初始化，是不能获取到 key 对应的 value 值的，所以需要借助 Collectins,.sort() 方法对键值对进行 sort 排序，再将排好序的键值对放入新的 Map 里。

public static void orderByValue(int[] nums) {
        Map<Integer, Integer> beforeSort = new TreeMap<>();
        for (int i=0; i<nums.length; i++) {
            beforeSort.put(nums[i], beforeSort.getOrDefault(nums[i], 0) + 1);
        }

        List<Map.Entry<Integer,Integer>> list = new ArrayList<>(beforeSort.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            public int compare(Map.Entry<Integer, Integer> o1,
                               Map.Entry<Integer, Integer> o2) {
                //降序
                // return o2.getValue().compareTo(o1.getValue());

                // 升序
                return o1.getValue().compareTo(o2.getValue());

            }
        });

        // 将排好序的 entry 放入有序映射中
        Map<Integer, Integer> afterSort = new LinkedHashMap<>();
        for (Map.Entry<Integer, Integer> entry : list) {
            afterSort.put(entry.getKey(), entry.getValue());
        }

        for (Map.Entry<Integer, Integer> entry : list) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }

测试一把

int[] nums = {4,1,-1,2,-1,2,3};
orderByValue(nums);

输出为：

1 : 1
3 : 1
4 : 1
-1 : 2
2 : 2