List的排序使用Comparator.sort进行排序
public static void main(String[] args) { List<Integer> ljh1 = new ArrayList<Integer>(); List<Integer> ljh2 = new LinkedList<Integer>(); for(int i=0;i<10;i++){ ljh1.add((int)(Math.random()*90+10)); ljh2.add((int)(Math.random()*90+10)); } Collections.sort(ljh1); Collections.sort(ljh2); System.out.println(ljh1.toString()); System.out.println(ljh2.toString()); System.out.println("------------------"); Collections.shuffle(ljh1); Collections.shuffle(ljh2); System.out.println(ljh1.toString()); System.out.println(ljh2.toString()); }
结果：
[16, 18, 18, 19, 24, 38, 58, 58, 77, 92]
[14, 32, 36, 44, 52, 61, 69, 80, 84, 97]------------------
[18, 24, 38, 19, 16, 92, 18, 58, 77, 58]
[32, 44, 52, 14, 61, 36, 97, 69, 80, 84]Process finished with exit code 0
看一下排序的源码，这是排序功能的主入口
一、入口
public static <T extends Comparable<? super T>> void sort(List<T> list) { list.sort(null); }
首先搞清<T extends Comparable<? super T>> 这乱七八糟的是什么
类型 T 必须是 Comparable 的子类，并且这个接口的类型是 T 或 T 的父类。
二、Collections.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); } }
下面会执行toArray方法，将这个list转换成数组，之后调用Array的sort方法对数组进行排序，排序完毕后再把数组的值写回该 List对象的list迭代器中。从而在该list对象中看到完成排序的结果。
下面重点分析一下Array.sort方法
三、Array.sort方法
public static <T> void sort(T[] a, Comparator<? super T> c) { if (c == null) { sort(a); } else { if (LegacyMergeSort.userRequested) legacyMergeSort(a, c); else TimSort.sort(a, 0, a.length, c, null, 0, 0); } }
注意执行到这一步的时候回有两个分支，
首先会判断c是否为空，如果为空，则直接执行sort方法
否则会判断LegacyMergeSort.userRequested的布尔值。这个值为True时执行legacyMergeSort排序算法，否则执行TimSort排序算法。
首先LegacyMergeSort.userRequested是个什么呢？？？我们打开源码看一看
static final class LegacyMergeSort { private static final boolean userRequested = java.security.AccessController.doPrivileged( new sun.security.action.GetBooleanAction( "java.util.Arrays.useLegacyMergeSort")).booleanValue(); }
实际上在代码中定义了一个内部类， 这里面有个属性是userResuest ，这个属性的值是一个security包中的doPrivileged方法产生的，这个方法是一个native方法，其实就是根据系统的属性来选择 旧的合并排序实现 还是 新的tim排序实现
下面我们对sort方法、legacyMergeSort()方法和TimSort.sort()方法进行源码层面的探究
3.1 sort方法
public static void sort(Object[] a) { if (LegacyMergeSort.userRequested) legacyMergeSort(a); else ComparableTimSort.sort(a, 0, a.length, null, 0, 0); }
这个sort跟上面的区别就是调用两种排序的参数不同，实际上是调用这两种排序的重载方法
3.2 legacyMergeSort(Object[] a)
private static void legacyMergeSort(Object[] a) { Object[] aux = a.clone(); mergeSort(aux, a, 0, a.length, 0); }
aux 是 a的对象拷贝，a其实就是之前的list转好的数组。 mergeSort方法其实就是归并排序算法（）
private static void mergeSort(Object[] src, //拷贝后的数组 Object[] dest,//原始数组 int low, // 0 int high, // list的长度 int off) { // 偏移量，如果用户希望对数组的某段进行排序，这个off就是偏移量。 int length = high - low; // Insertion sort on smallest arrays if (length < INSERTIONSORT_THRESHOLD) { // 当长度小于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; } // Recursively sort halves of dest into src //当长度大于等于7的时候 int destLow = low; int destHigh = high; low += off; //off = 0 ;low = 0 high += off; //off = 0 ;high = list的长度 int mid = (low + high) >>> 1; //list的长度的二进制数右移一位，如果是8则为4 如果是7则为3.相当于将数组进行分段，分成两段 mergeSort(dest, src, low, mid, -off); //对前半段进行排序，如果前半段小于7则插入排序，否则继续拆分成两段 mergeSort(dest, src, mid, high, -off); //对后半段进行排序，剩下的同上 // 如果列表已经排序，只需从SRC复制到DEST。这是一个优化，导致更快的排序几乎有序的列表。 // 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; } // 将src的结果写入dest，也就是将原始数组的值覆盖为排序后的值 // 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) //mid比high大或等于 或 low小于mid并且 low的数小于mid dest[i] = src[p++]; //如果src的最小值小于src的分段的mid值，那么就把dest的值从头开始替换成src的排序后的值 else dest[i] = src[q++]; //如果src的最小值小于src的分段的mid值，那么就把dest的值从头开始替换成src的排序后的值 } }
最后一段程序其实就是将两段值用循环进行一个合并
例如 5 7 6 9 2 8 7 5 6 0 这个list。
首先分段： 5 7 6 9 2 | 8 7 5 6 0
其次分别排序： 2 5 6 7 9 | 0 5 6 7 8
再其次判断每个分段是否小于7 小于的话 执行最后的循环
if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
这步将返回true 于是将0放在第一位。
一次类推进行排序后的数据重组。
这就是归并排序算法
3.3 ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
TimSort算法是一种起源于归并排序和插入排序的混合排序算法，设计初衷是为了在真实世界中的各种数据中可以有较好的性能。
static void sort(Object[] a, int lo, int hi, Object[] work, int workBase, int workLen) { assert a != null && lo >= 0 && lo <= hi && hi <= a.length; // 增加一个断言 int nRemaining = hi - lo; //定义一个待排序的数组长度 if (nRemaining < 2) //每个Remaining必须有两个及以上元素 return; // Arrays of size 0 and 1 are always sorted // If array is small, do a "mini-TimSort" with no merges if (nRemaining < MIN_MERGE) { //如果数组小于32,执行binarySort(二叉排序算法) int initRunLen = countRunAndMakeAscending(a, lo, hi); binarySort(a, lo, hi, lo + initRunLen); return; } /** * March over the array once, left to right, finding natural runs, * extending short natural runs to minRun elements, and merging runs * to maintain stack invariant. */ ComparableTimSort ts = new ComparableTimSort(a, work, workBase, workLen); int minRun = minRunLength(nRemaining); // 选取minRun大小,数组长度/2，之后待排序数组将被分成以minRun大小为区块的一块块子数组 do { // Identify next run int runLen = countRunAndMakeAscending(a, lo, hi); //找到一个已经是升序的数组，如果是降序则会进行翻转，并返回这个数组的偏移量 // If run is short, extend to min(minRun, nRemaining) if (runLen < minRun) { //如果切分后的数组长度小于32 则执行二叉树排序 int force = nRemaining <= minRun ? nRemaining : minRun; //偏移量 binarySort(a, lo, lo + force, lo + runLen); runLen = force; } //对当前的各区块进行merge，merge会满足以下原则（假设X，Y，Z为相邻的三个区块）： //a) 只对相邻的区块merge //b) 若当前区块数仅为2，If X<=Y，将X和Y merge //b) 若当前区块数>=3，If X<=Y+Z，将X和Y merge，直到同时满足X>Y+Z和Y>Z // Push run onto pending-run stack, and maybe merge ts.pushRun(lo, runLen); ts.mergeCollapse(); // Advance to find next run lo += runLen; nRemaining -= runLen; } while (nRemaining != 0); // Merge all remaining runs to complete sort assert lo == hi; ts.mergeForceCollapse(); assert ts.stackSize == 1; }
TimSort 算法为了减少对升序部分的回溯和对降序部分的性能倒退，将输入按其升序和降序特点进行了分区。排序的输入的单位不是一个个单独的数字，而是一个个的块-分区。其中每一个分区叫一个run。针对这些 run 序列，每次拿一个 run 出来按规则进行合并。每次合并会将两个 run合并成一个 run。合并的结果保存到栈中。合并直到消耗掉所有的 run，这时将栈上剩余的 run合并到只剩一个 run 为止。这时这个仅剩的 run 便是排好序的结果。
在这里分享一篇专门讲这个排序的例子：
出处：https://blog.csdn.net/bruce_6/article/details/38299199
示例
*注意*：为了演示方便，我将TimSort中的minRun直接设置为2，否则我不能用很小的数组演示。。。同时把MIN_MERGE也改成2（默认为32），这样避免直接进入binary sort。
初始数组为[7,5,1,2,6,8,10,12,4,3,9,11,13,15,16,14]
=> 寻找连续的降序或升序序列 (2.2.1)，同时countRunAndMakeAscending函数会保证它为升序
[1,5,7] [2,6,8,10,12,4,3,9,11,13,15,16,14]
=> 入栈 (2.2.3)
当前的栈区块为[3]=> 进入merge循环 (2.2.4)
do not merge因为栈大小仅为1=> 寻找连续的降序或升序序列 (2.2.1)
[1,5,7] [2,6,8,10,12] [4,3,9,11,13,15,16,14]=> 入栈 (2.2.3)
当前的栈区块为[3, 5]=> 进入merge循环 (2.2.4)
merge因为runLen[0]<=runLen[1]
1) gallopRight：寻找run1的第一个元素应当插入run0中哪个位置（”2”应当插入”1”之后），然后就可以忽略之前run0的元素（都比run1的第一个元素小）
2) gallopLeft：寻找run0的最后一个元素应当插入run1中哪个位置（”7”应当插入”8”之前），然后就可以忽略之后run1的元素（都比run0的最后一个元素大）
这样需要排序的元素就仅剩下[5,7] [2,6]，然后进行mergeLow
完成之后的结果：
[1,2,5,6,7,8,10,12] [4,3,9,11,13,15,16,14]=> 入栈 (2.2.3)
当前的栈区块为[8]
退出当前merge循环因为栈中的区块仅为1=> 寻找连续的降序或升序序列 (2.2.1)
[1,2,5,6,7,8,10,12] [3,4] [9,11,13,15,16,14]
=> 入栈 (2.2.3)
当前的栈区块大小为[8,2]
=> 进入merge循环 (2.2.4)
do not merge因为runLen[0]>runLen[1]
=> 寻找连续的降序或升序序列 (2.2.1)
[1,2,5,6,7,8,10,12] [3,4] [9,11,13,15,16] [14]
=> 入栈 (2.2.3)
当前的栈区块为[8,2,5]
=>
do not merege run1与run2因为不满足runLen[0]<=runLen[1]+runLen[2]
merge run2与run3因为runLen[1]<=runLen[2]
1) gallopRight：发现run1和run2就已经排好序
完成之后的结果：
[1,2,5,6,7,8,10,12] [3,4,9,11,13,15,16] [14]
=> 入栈 (2.2.3)
当前入栈的区块大小为[8,7]
退出merge循环因为runLen[0]>runLen[1]
=> 寻找连续的降序或升序序列 (2.2.1)
最后只剩下[14]这个元素：[1,2,5,6,7,8,10,12] [3,4,9,11,13,15,16] [14]
=> 入栈 (2.2.3)
当前入栈的区块大小为[8,7,1]
=> 进入merge循环 (2.2.4)
merge因为runLen[0]<=runLen[1]+runLen[2]
因为runLen[0]>runLen[2]，所以将run1和run2先合并。（否则将run0和run1先合并）
1) gallopRight & 2) gallopLeft
这样需要排序的元素剩下[13,15] [14]，然后进行mergeHigh
完成之后的结果：
[1,2,5,6,7,8,10,12] [3,4,9,11,13,14,15,16] 当前入栈的区块为[8,8]
=>
继续merge因为runLen[0]<=runLen[1]
1) gallopRight & 2) gallopLeft
需要排序的元素剩下[5,6,7,8,10,12] [3,4,9,11]，然后进行mergeHigh
完成之后的结果：
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] 当前入栈的区块大小为[16]
=>
不需要final merge因为当前栈大小为1
=>
结束