Java Arrays.sort源代码解析

基本类型：采用调优的快速排序（Primitive（int，float等原型数据））；

对象类型：采用改进的归并排序（Object对象数组）。

源码中选择划分元的方法:

　　　　当数组大小为 size=7 时 ，取数组中间元素作为划分元。int n=m>>1;(此方法值得借鉴)

　　　　当数组大小7< size<=40时，取首、中、末三个元素中间大小的元素作为划分元。

　　　　当数组大小 size>40 时 ，从待排数组中较均匀的选择9个元素，选出一个伪中数做为划分元。

根据划分元 v ，形成不变式 v* (v)* v*

　　普通的快速排序算法，经过一次划分后，将划分元排到素组较中间的位置，左边的元素小于划分元，右边的元素大于划分元，而没有将与划分元相等的元素放在其附近，这一点，在Arrays.sort()中得到了较大的优化。

　　举例：15、93、15、41、6、15、22、7、15、20

　　因 7

　　经过一次换分后： 15、15、7、6、41、20、22、93、15、15. 与划分元相等的元素都移到了素组的两边。

　　接下来将与划分元相等的元素移到数组中间来，形成：7、6、15、15、15、15、41、20、22、93.

　　最后递归对两个区间进行排序[7、6]和[41、20、22、93]. 
　　

1. package com.util;
2. import java.lang.reflect.Array;
3. publicclassArraysObject{
4. privatestaticfinalint INSERTIONSORT_THRESHOLD=7;
6. privateArraysObject(){}
8. publicstaticvoid sort(Object[] a){
9. //java.lang.Object.clone()，理解深表复制和浅表复制
10. Object[] aux =(Object[]) a.clone();
11. mergeSort(aux, a,0, a.length,0);
12. }
14. publicstaticvoid sort(Object[] a,int fromIndex,int toIndex){
15. rangeCheck(a.length, fromIndex, toIndex);
16. Object[] aux = copyOfRange(a, fromIndex, toIndex);
17. mergeSort(aux, a, fromIndex, toIndex,-fromIndex);
18. }
20. /**
21. * Src is the source array that starts at index 0
22. * Dest is the (possibly larger) array destination with a possible offset
23. * low is the index in dest to start sorting
24. * high is the end index in dest to end sorting
25. * off is the offset to generate corresponding low, high in src
26. */
27. privatestaticvoid mergeSort(Object[] src,Object[] dest,int low,
28. int high,int off){
29. int length = high- low;
31. // Insertion sort on smallest arrays
32. if(length< INSERTIONSORT_THRESHOLD){
33. for(int i= low; i< high; i++)
34. for(int j= i; j> low&&
35. ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
36. swap(dest, j, j-1);
37. return;
38. }
40. // Recursively sort halves of dest into src
41. int destLow = low;
42. int destHigh = high;
43. low+= off;
44. high+= off;
45. /*
46. * >>>：无符号右移运算符
47. * expression1 >>> expresion2：expression1的各个位向右移expression2
48. * 指定的位数。右移后左边空出的位数用0来填充。移出右边的位被丢弃。
49. * 例如：-14>>>2； 结果为：1073741820
50. */
51. int mid =(low+ high)>>>1;
52. mergeSort(dest, src, low, mid,-off);
53. mergeSort(dest, src, mid, high,-off);
55. // If list is already sorted, just copy from src to dest. This is an
56. // optimization that results in faster sorts for nearly ordered lists.
57. if(((Comparable) src[mid-1]).compareTo(src[mid])<=0){
58. System.arraycopy(src, low, dest, destLow, length);
59. return;
60. }
62. // Merge sorted halves (now in src) into dest
63. for(int i= destLow, p= low, q= mid; i< destHigh; i++){
64. if(q>= high|| p< mid
65. &&((Comparable) src[p]).compareTo(src[q])<=0)
66. dest[i]= src[p++];
67. else
68. dest[i]= src[q++];
69. }
70. }
72. /**
73. * Check that fromIndex and toIndex are in range, and throw an appropriate
74. * exception if they aren't.
75. */
76. privatestaticvoid rangeCheck(int arrayLen,int fromIndex,int toIndex){
77. if(fromIndex> toIndex)
78. thrownewIllegalArgumentException("fromIndex("+ fromIndex
79. +") > toIndex("+ toIndex+")");
80. if(fromIndex<0)
81. thrownewArrayIndexOutOfBoundsException(fromIndex);
82. if(toIndex> arrayLen)
83. thrownewArrayIndexOutOfBoundsException(toIndex);
84. }
86. publicstatic<T> T[] copyOfRange(T[] original,int from,int to){
87. return copyOfRange(original, from, to,(Class<T[]>) original.getClass());
88. }
90. publicstatic<T, U> T[] copyOfRange(U[] original,int from,int to,
91. Class<?extends T[]> newType){
92. int newLength = to- from;
93. if(newLength<0)
94. thrownewIllegalArgumentException(from+" > "+ to);
95. T[] copy =((Object) newType==(Object)Object[].class)
96. ?(T[])newObject[newLength]
97. :(T[])Array.newInstance(newType.getComponentType(), newLength);
98. System.arraycopy(original, from, copy,0,
99. Math.min(original.length- from, newLength));
100. return copy;
101. }
103. /**
104. * Swaps x[a] with x[b].
105. */
106. privatestaticvoid swap(Object[] x,int a,int b){
107. Object t = x[a];
108. x[a]= x[b];
109. x[b]= t;
110. }
111. }

对于Object类型源码分析如下

1. package com.util;
3. import java.lang.reflect.Array;
5. publicclassArraysObject{
6. privatestaticfinalint INSERTIONSORT_THRESHOLD=7;
8. privateArraysObject(){}
10. publicstaticvoid sort(Object[] a){
11. //java.lang.Object.clone()，理解深表复制和浅表复制
12. Object[] aux =(Object[]) a.clone();
13. mergeSort(aux, a,0, a.length,0);
14. }
16. publicstaticvoid sort(Object[] a,int fromIndex,int toIndex){
17. rangeCheck(a.length, fromIndex, toIndex);
18. Object[] aux = copyOfRange(a, fromIndex, toIndex);
19. mergeSort(aux, a, fromIndex, toIndex,-fromIndex);
20. }
22. /**
23. * Src is the source array that starts at index 0
24. * Dest is the (possibly larger) array destination with a possible offset
25. * low is the index in dest to start sorting
26. * high is the end index in dest to end sorting
27. * off is the offset to generate corresponding low, high in src
28. */
29. privatestaticvoid mergeSort(Object[] src,Object[] dest,int low,
30. int high,int off){
31. int length = high- low;
33. // Insertion sort on smallest arrays
34. if(length< INSERTIONSORT_THRESHOLD){
35. for(int i= low; i< high; i++)
36. for(int j= i; j> low&&
37. ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
38. swap(dest, j, j-1);
39. return;
40. }
42. // Recursively sort halves of dest into src
43. int destLow = low;
44. int destHigh = high;
45. low+= off;
46. high+= off;
47. /*
48. * >>>：无符号右移运算符
49. * expression1 >>> expresion2：expression1的各个位向右移expression2
50. * 指定的位数。右移后左边空出的位数用0来填充。移出右边的位被丢弃。
51. * 例如：-14>>>2； 结果为：1073741820
52. */
53. int mid =(low+ high)>>>1;
54. mergeSort(dest, src, low, mid,-off);
55. mergeSort(dest, src, mid, high,-off);
57. // If list is already sorted, just copy from src to dest. This is an
58. // optimization that results in faster sorts for nearly ordered lists.
59. if(((Comparable) src[mid-1]).compareTo(src[mid])<=0){
60. System.arraycopy(src, low, dest, destLow, length);
61. return;
62. }
64. // Merge sorted halves (now in src) into dest
65. for(int i= destLow, p= low, q= mid; i< destHigh; i++){
66. if(q>= high|| p< mid
67. &&((Comparable) src[p]).compareTo(src[q])<=0)
68. dest[i]= src[p++];
69. else
70. dest[i]= src[q++];
71. }
72. }
74. /**
75. * Check that fromIndex and toIndex are in range, and throw an appropriate
76. * exception if they aren't.
77. */
78. privatestaticvoid rangeCheck(int arrayLen,int fromIndex,int toIndex){
79. if(fromIndex> toIndex)
80. thrownewIllegalArgumentException("fromIndex("+ fromIndex
81. +") > toIndex("+ toIndex+")");
82. if(fromIndex<0)
83. thrownewArrayIndexOutOfBoundsException(fromIndex);
84. if(toIndex> arrayLen)
85. thrownewArrayIndexOutOfBoundsException(toIndex);
86. }
88. publicstatic<T> T[] copyOfRange(T[] original,int from,int to){
89. return copyOfRange(original, from, to,(Class<T[]>) original.getClass());
90. }
92. publicstatic<T, U> T[] copyOfRange(U[] original,int from,int to,
93. Class<?extends T[]> newType){
94. int newLength = to- from;
95. if(newLength<0)
96. thrownewIllegalArgumentException(from+" > "+ to);
97. T[] copy =((Object) newType==(Object)Object[].class)
98. ?(T[])newObject[newLength]
99. :(T[])Array.newInstance(newType.getComponentType(), newLength);
100. System.arraycopy(original, from, copy,0,
101. Math.min(original.length- from, newLength));
102. return copy;
103. }
105. /**
106. * Swaps x[a] with x[b].
107. */
108. privatestaticvoid swap(Object[] x,int a,int b){
109. Object t = x[a];
110. x[a]= x[b];
111. x[b]= t;
112. }
113. }