Collections.sort()实现按对象的某属性进行排序

Collections.sort()是Comparator接口的方法，但为了是实现自定义排序，必须覆写Comparator的compare()方法.
此方法的使用如下：

public  void sort(ArrayList<Pcb> list) {
    Comparator<Pcb> comparator = new Comparator<Pcb>() {
        @Override
        */**在此方法中，
          *return  o1.getPriority()-o2.getPriority();    则表示定义的自定义排序方法为：升序排列
          *return  o2.getPriority()-o1.getPriority();     则表示按确定的属性降序排列
         /*
        public int compare(Pcb o1, Pcb o2) {
            return o2.getPriority()-o1.getPriority();
        }
    };
    //Collections.sort(要排序的实例化对象列表，自定义的实现Comparator的实例化对象);
    Collections.sort(list, comparator);
}

固然，最令人疑惑不解的地方就是compare（）方法的覆写了，为什么o1.getPriority()-o2.getPriority();就是升序排列？return o2.getPriority()-o1.getPriority(); 就是降序排列？
下面，我们来看一下源代码，搞清楚为何如此：

//Collections的源码
public static <T> void sort(List<T> list, Comparator<? super T> c) {
    list.sort(c);
}

由上面源码可以发现，Collections.sort();方法中调用了list.sort()方法。再看list.sort()中的sort()方法。

default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

list.sort()方法中又调用了String类的Arrays.sort()方法;下面看最后一步，Arrays.sort()中的sort()方法到底是如何实现的？

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

    // Insertion sort on smallest arrays
    if (length < INSERTIONSORT_THRESHOLD) {
        for (int i=low; i<high; i++)
            for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
                swap(dest, j, j-1);
        return;
    }

private static void swap(Object[] x, int a, int b) {
    Object t = x[a];
    x[a] = x[b];
    x[b] = t;
}

可以发现Arrays.sort()实际调用的是merge Sort（）即归并排序。其中对两个参数进行了swap（交换）。`
若return的结果大于0则交换两个参数的位置，不大于则不交换，继续向后判断。

此时就可进行总结了：

return o1.getPriority()-o2.getPriority();
若o1.getPriority()<o2.getPriority()则返回的结果<0.则不交换位置，若o1.getPriority()>o2.getPriority()则返回的结果>0.则交换位置，最终的序列为从小到大排序.
return o2.getPriority()-o1.getPriority();
若o1.getPriority()<o2.getPriority()则返回的结果>0.则交换位置，若o1.getPriority()>o2.getPriority()则返回的结果<0.则不交换位置，最终的序列为从大到小排序…