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

最新推荐文章于 2023-04-02 02:56:17 发布

原创最新推荐文章于 2023-04-02 02:56:17 发布 · 3.4k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#list #collections #arrays #object #optimization #jdk

java 同时被 2 个专栏收录

23 篇文章

订阅专栏

算法

20 篇文章

订阅专栏

本文深入探讨了Java中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做的一个小优化吧。

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