Comparable vs Comparator

sorting 排序

sorting-in-java
Java中提供了Arrays.sort()和Collections.sort()方法用来提供排序，其中排序算法使用的是 QuickSort 快速排序算法，并且默认是升序排列，如果使用降序排列，可以使用Collections.reverseOrder()方法做为参数，同时sort方法还提供了局部排序的方法。

@Test
    public void testA(){
        
        Comparator comparator = (o1, o2) -> 0;
        Comparable comparable = o -> 0;

        Integer[] arr = { 13, 7, 6, 45, 21, 9, 101, 102 };
        Arrays.sort(arr, 1, 3);
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr, Collections.reverseOrder());
        System.out.println(Arrays.toString(arr));
        
        String[] str = {"z", "a", "f", "b", "n", "m"};
        Arrays.sort(str, 0, 3);
        System.out.println(Arrays.toString(str));
        Arrays.sort(str);
        System.out.println(Arrays.toString(str));
        Arrays.sort(str, Collections.reverseOrder());
        System.out.println(Arrays.toString(str));
    }
    
    @Test
    public void testB(){
        List<Integer> list = Arrays.asList(13, 7, 6, 45, 21, 9, 101, 102 );
        Collections.sort(list);
        System.out.println(list);
        Collections.sort(list, Collections.reverseOrder());
        System.out.println(list);
        
        List<String> strList = Arrays.asList("z", "a", "f", "b", "n", "m");
        Collections.sort(strList);
        System.out.println(strList);
        Collections.sort(strList, Collections.reverseOrder());
        System.out.println(strList);
    }

comparable-vs-comparator

// 独立的比较器
import java.util.Comparator;

// 需要类实现接口，重写compareTo方法
import java.lang.Comparable;

与此同时sort方法还可以接收Comparator比较器做为参数来实现自定义排序。Comparable 可以让实现它的类的对象进行比较，类内部要实现 compareTo 方法。

class A implements Comparable<A>{
    private int a;
    
    /**
     * - a1.compareTo(a2) > 0 即 a1 > a2
     * - a1.compareTo(a2) = 0 即 a1 = a2
     * - a1.compareTo(a2) < 0 即 a1 < a2
     */
    @Override
    public int compareTo(A o) {
        
        // 兼容NP场景;
        if(Objects.isNull(o)) return 1;
        return a - o.a;
    }
    
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.compareTo(null));
    }
}

自然排序需要类实现 Comparable接口，同时重写 comparaTo 方法。Comparator 则是在外部制定排序规则，然后作为排序策略参数传递给某些类，比如 Collections.sort(), Arrays.sort(), 或者一些内部有序的集合（比如 SortedSet，SortedMap 等）。

class A {
    private int a;
    private static final Comparator<A> comparator = (o1, o2) -> o1.a - o2.a;
    
    public static void main(String[] args) {
        A[] array = { new A(2), new A(1), new A(3)};
        Arrays.sort(array, comparator);
        for (A a : array) {
            System.out.println(a.a);
        }
    }
    
    public A(int a){
        this.a = a;
    }
}

参考

• geeksForGeeks-java
• sorting-in-java/