//基本类型都是调用另一个类的排序函数,是快排,当我也想顺便把这个也贴上来的时候发现,一个int的排序有400行!!!我还是决定,再开一篇在讨论吧publicstaticvoidsort(int[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
//可以只排其中的一部分publicstaticvoidsort(int[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
//1.8之后,对排序做了进一步的优化,调用了另一个类的排序,那个类里面也是调用的快排publicstaticvoidparallelSort(int[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
elsenew ArraysParallelSortHelpers.FJInt.Sorter
(null, a, newint[n], 0, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
publicstaticvoidparallelSort(int[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
elsenew ArraysParallelSortHelpers.FJInt.Sorter
(null, a, newint[n], fromIndex, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
Object的排序不同于基本类型,使用的是归并排序+插入排序
publicstaticvoidsort(Object[] a) {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a);
else
ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
}
privatestaticvoidlegacyMergeSort(Object[] a) {
Object[] aux = a.clone();
mergeSort(aux, a, 0, a.length, 0);
}
privatestaticfinalint INSERTIONSORT_THRESHOLD = 7;
privatestaticvoidmergeSort(Object[] src,
Object[] dest,
int low,
int high,
int off) {
int length = high - low;
//当元素个数小于7个的时候,直接插入排序// Insertion sort on smallest arraysif (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 srcint 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 destfor(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++];
}
}
privatestaticvoidswap(Object[] x, int a, int b) {
Object t = x[a];
x[a] = x[b];
x[b] = t;
}
二分查找
publicstaticintbinarySearch(int[] a, int key) {
return binarySearch0(a, 0, a.length, key);
}
//也可以是从一段区间中查找publicstaticintbinarySearch(int[] a, int fromIndex, int toIndex,
int key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
//注意,Java中个给的二分,只是说这段区间中有没有,并返回该index,而不是返回第一个出现的位置或者是最后一次出现的位置privatestaticintbinarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
elseif (midVal > key)
high = mid - 1;
//居然是找到了就返回elsereturn mid; // key found
}
//并不是找不到就返回-1,而是-(low + 1),所以区间查找的话,判有没有要看的是该index的正负return -(low + 1); // key not found.
}
判两个数组是否相等
publicstaticbooleanequals(int[] a, int[] a2) {
if (a==a2)
returntrue;
if (a==null || a2==null)
returnfalse;
int length = a.length;
if (a2.length != length)
returnfalse;
for (int i=0; i<length; i++)
if (a[i] != a2[i])
returnfalse;
returntrue;
}
填充
publicstaticvoidfill(int[] a, int val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
//可以填充一段区间publicstaticvoidfill(int[] a, int fromIndex, int toIndex, int val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
//这里给出了一种计算hash值的方法,用的数是31publicstaticinthashCode(int a[]) {
if (a == null)
return0;
int result = 1;
for (int element : a)
result = 31 * result + element;
return result;
}
//如果是多维数组,计算hash的方法publicstaticintdeepHashCode(Object a[]) {
if (a == null)
return0;
int result = 1;
for (Object element : a) {
int elementHash = 0;
//递归求hash,算是一大亮点吧if (element instanceof Object[])
elementHash = deepHashCode((Object[]) element);
elseif (element instanceofbyte[])
elementHash = hashCode((byte[]) element);
elseif (element instanceofshort[])
elementHash = hashCode((short[]) element);
elseif (element instanceofint[])
elementHash = hashCode((int[]) element);
elseif (element instanceoflong[])
elementHash = hashCode((long[]) element);
elseif (element instanceofchar[])
elementHash = hashCode((char[]) element);
elseif (element instanceoffloat[])
elementHash = hashCode((float[]) element);
elseif (element instanceofdouble[])
elementHash = hashCode((double[]) element);
elseif (element instanceofboolean[])
elementHash = hashCode((boolean[]) element);
elseif (element != null)
elementHash = element.hashCode();
result = 31 * result + elementHash;
}
return result;
}
toString
publicstatic String toString(int[] a) {
if (a == null)
return"null";
int iMax = a.length - 1;
if (iMax == -1)
return"[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}