模板方法应用-Arrays.sort(Object[] a)以及Comparable和Comparator的区别

Comparable和Comparator的区别

Arrays.sort(Object[] a)定义

public static void sort(Object[] a)根据元素的自然顺序对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Comparable 接口。此外，数组中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，e1.compareTo(e2) 不得抛出 ClassCastException）。
保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。 

参数：
a - 要排序的数组 
抛出： 
ClassCastException - 如果数组包含不可相互比较的 的元素（例如，字符串和整数）。

代码分析

• 第一步，调用Arrays.sort(Object[] a)方法

其中Person为自定义类

Person[] person = {}; 
 Arrays.sort(person);

 

• 第二步，进入sort方法

默认进入第一个传统方法

public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
    }

第三步，进入legacyMergeSort方法

private static void legacyMergeSort(Object[] a) {
        Object[] aux = a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }

第四步，进入mergeSort方法

private static void mergeSort(Object[] src, Object[] dest, int low, int high, int off) {
        int length = high - low;

        // 小数组用插入排序
        if (length < 7) {
            for (int i = low; i < high; i++)
                for (int j = i; j > low && ((Comparable) dest[j - 1]).compareTo(dest[j]) > 0; j--)
                    swap(dest, j, j - 1);
            return;
        }

        // 其他的使用递归排序
        int destLow = low;
        int destHigh = high;
        low += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

        //已经排好序
        if (((Comparable) src[mid - 1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // 合并排序
        for (int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable) src[p]).compareTo(src[q]) <= 0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

其中((Comparable) dest[j - 1]).compareTo(dest[j]) > 0，使用Comparable接口

// 小数组用插入排序
        if (length < 7) {
            for (int i = low; i < high; i++)
                for (int j = i; j > low && ((Comparable) dest[j - 1]).compareTo(dest[j]) > 0; j--)
                    swap(dest, j, j - 1);
            return;
        }

其中((Comparable) src[mid - 1]).compareTo(src[mid]) <= 0，使用Comparable接口

if (((Comparable) src[mid - 1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

其中((Comparable) src[p]).compareTo(src[q]) <= 0，使用Comparable接口

for (int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable) src[p]).compareTo(src[q]) <= 0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }

问题
Arrays.sort(Object[] a)为传入对象a类型要继承Comparable接口，然后通过compareTo比较两个数大小，最终完成排序

引入模板方法思维

为什么要这样设计？ 
因为设计者不清楚到底是什么具体的类属性在进行比较，如Person类，通过年龄比较谁大谁小，其他的对象是通过其他的比较标准

一个完整例子
需要比较的类

package headfirst.hd.template.java;

public class Person implements Comparable<Person> {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(Person o) {

        //升序
        if (this.age > o.age) {
            return 1;
        }

        if (this.age < o.age) {
            return -1;
        }

        return 0;
    }

}

转自：

https://blog.csdn.net/dengjili/article/details/79646502