Comparable 和 Comparator 的使用

首先看 Comparable 的使用

public class code {
    static class B implements Comparable<B> {
        int m;
        int n;
        B(int m, int n){
            this.m = m;
            this.n = n;
        }
        @Override
        public int compareTo(B o) {
            if (m != o.m){
                return o.m-m;
            }
            if (m == o.m){
                if (n != o.n) return n - o.n;
            }
            return 0;
        }
    }
    public static void main(String[] args) {
        B[] b = new B[3];
        b[0] = new B(2,3);
        b[1] = new B(2,4);
        b[2] = new B(1,5);
        for (B bb:b){
            System.out.println(bb.m+ "->" +bb.n);
        }
    }
}

如果要对对象进行比较，要实现 Comparable 接口，并覆盖 compareTo 方法制定比较规则

在这里的规则是 如果 被比较者和后面的比较者的 m 值不相等，按照 m 的降序排序  如果 m 值相等，按照 n 值的升序排序
return 0 表示两者相等

程序输出结果是

---

public class code {
    public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 1;
        arr[1] = 3;
        arr[2] = 2;
        Arrays.sort(arr);
        for (int a:arr){
            System.out.println(a);
        }
    }
}
输出结果：1 2 3

可以看出默认的排序方式是升序，那么如何进行降序排序呢

public class code {
    public static void main(String[] args) {
        Integer[] arr = new Integer[3];
        arr[0] = 1;
        arr[1] = 3;
        arr[2] = 2;
        Arrays.sort(arr,new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        for (int a:arr){
            System.out.println(a);
        }
    }
}

总结一下，这两种比较器Comparable和Comparator，后者相比前者有如下优点：

个性化比较：如果实现类没有实现Comparable接口，又想对两个类进行比较（或者实现类实现了Comparable接口，但是对compareTo方法内的比较算法不满意），那么可以实现Comparator接口，自定义一个比较器，写比较算法。
解耦：实现Comparable接口的方式比实现Comparator接口的耦合性要强一些，如果要修改比较算法，要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改。从这个角度说，其实有些不太好，尤其在我们将实现类的.class文件打成一个.jar文件提供给开发者使用的时候。