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. public class ArraysObject {
4. private static final int INSERTIONSORT_THRESHOLD = 7;
6. private ArraysObject() {}
8. public static void sort(Object[] a) {
9. //java.lang.Object.clone()，理解深表复制和浅表复制
10. Object[] aux = (Object[]) a.clone();
11. mergeSort(aux, a, 0, a.length, 0);
12. }
14. public static void 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. private static void 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. private static void rangeCheck(int arrayLen, int fromIndex, int toIndex) {
77. if (fromIndex > toIndex)
78. throw new IllegalArgumentException("fromIndex(" + fromIndex
79. + ") > toIndex(" + toIndex + ")");
80. if (fromIndex < 0)
81. throw new ArrayIndexOutOfBoundsException(fromIndex);
82. if (toIndex > arrayLen)
83. throw new ArrayIndexOutOfBoundsException(toIndex);
84. }
86. public static <T> T[] copyOfRange(T[] original, int from, int to) {
87. return copyOfRange(original, from, to, (Class<T[]>) original.getClass());
88. }
90. public static <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. throw new IllegalArgumentException(from + " > " + to);
95. T[] copy = ((Object) newType == (Object) Object[].class)
96. ? (T[]) new Object[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. private static void 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. public class ArraysObject {
6. private static final int INSERTIONSORT_THRESHOLD = 7;
8. private ArraysObject() {}
10. public static void sort(Object[] a) {
11. //java.lang.Object.clone()，理解深表复制和浅表复制
12. Object[] aux = (Object[]) a.clone();
13. mergeSort(aux, a, 0, a.length, 0);
14. }
16. public static void 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. private static void 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. private static void rangeCheck(int arrayLen, int fromIndex, int toIndex) {
79. if (fromIndex > toIndex)
80. throw new IllegalArgumentException("fromIndex(" + fromIndex
81. + ") > toIndex(" + toIndex + ")");
82. if (fromIndex < 0)
83. throw new ArrayIndexOutOfBoundsException(fromIndex);
84. if (toIndex > arrayLen)
85. throw new ArrayIndexOutOfBoundsException(toIndex);
86. }
88. public static <T> T[] copyOfRange(T[] original, int from, int to) {
89. return copyOfRange(original, from, to, (Class<T[]>) original.getClass());
90. }
92. public static <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. throw new IllegalArgumentException(from + " > " + to);
97. T[] copy = ((Object) newType == (Object) Object[].class)
98. ? (T[]) new Object[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. private static void swap(Object[] x, int a, int b) {
109. Object t = x[a];
110. x[a] = x[b];
111. x[b] = t;
112. }
113. }