深入分析集合List的排序Collections.sort

List接口本身未提供sort的方法。

在jdk中提供了一个集合操作工具类Collections来操作集合。

查看Collections类，可以发下如下两个方法：

static <T extends Comparable<? super T>> void	sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。
static <T> void	sort(List<T> list,Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。

第一个方法，是要求T必须实现Comparator接口。

第二个方法，传一个Comparator接口的实现。

打开Collections类查看sort方法的源码 ，如下：

    public static <T extends Comparable<? super T>> void sort(List<T> list) {
	Object[] a = list.toArray();
	Arrays.sort(a);
	ListIterator<T> i = list.listIterator();
	for (int j=0; j<a.length; j++) {
	    i.next();
	    i.set((T)a[j]);
	}
    }

会发现，其实它调用的是Arrays.sort（Object[] a）这个方法，对对象排序。

Arrays类又是jdk为操作数组提供的一个工具类，里面提供了很多对数组的操作方法，如排序、查找等。

我们这里主要是对其中的sort方法进行一个简单的分析，打开Arrays类的sort实现代码，如下：

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

里面有调用了mergeSort这个方法对目标数组进行排序，单从方法的名字来看就知道是个归并排序，小弟之前也写过 java实现的归并排序，与这里略有不同，

此方法的代码如下：

 private static void mergeSort(Object[] src,
				  Object[] dest,
				  int low,
				  int high,
				  int off) {
	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 &&
			 ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        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 list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // Merge sorted halves (now in src) into dest
        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++];
        }
    }

jdk里面对归并做了一个小小的改进，那就是当数组的长度于INSERTIONSORT_THRESHOLD（=7）这个常数的时候使用的是插入排序（Insertion sort ）。

因为当数组元素较小时，比如6个，最好的情况下插入排序移动0次元素，最坏的情况是10次，而且归并则始终是nlogn，所以这是jdk做的一个小优化吧。

如果解释的不对的话请大家纠结，呵呵。