工具类特征：
构造器必须是私有的，工具类一般不需要初始化，可以直接使用；工具类的方法必须是被static final方法修饰，保证方法不可变；不要在工具类方法中对共享变量有修改的操作，如果一定要有，必须加锁保证线程安全；工具类的所有方法都没有线程安全问题；
(资料图片仅供参考)
一、Arrays
Arrays主要提供了对数组的高效操作，包括排序、查找、填充、拷贝、相等判断等操作；
1、sort(int[] a)
1.1、JDK1.6
1.1.1、源码
// int类型数组排序public static void sort(int[] a) {sort1(a, 0, a.length);}private static void sort1(int x[], int off, int len) {// Insertion sort on smallest arrays if (len < 7) {for (int i = off; i < len + off; i++) for (int j = i; j > off && x[j - 1] > x[j]; j--) swap(x, j, j - 1); return; } // Choose a partition element, v int m = off + (len >> 1); // Small arrays, middle element if (len > 7) {int l = off; int n = off + len - 1; if (len > 40) {// Big arrays, pseudomedian of 9 int s = len / 8; l = med3(x, l, l + s, l + 2 * s); m = med3(x, m - s, m, m + s); n = med3(x, n - 2 * s, n - s, n); } m = med3(x, l, m, n); // Mid-size, med of 3 } int v = x[m]; // Establish Invariant: v* (v)* v* int a = off, b = a, c = off + len - 1, d = c; while (true) {while (b <= c && x[b] <= if="" while="" c="">= b && x[c] >= v) {if (x[c] == v) swap(x, c, d--); c--; } if (b > c) break; swap(x, b++, c--); } // Swap partition elements back to middle int s, n = off + len; s = Math.min(a - off, b - a); vecswap(x, off, b - s, s); s = Math.min(d - c, n - d - 1); vecswap(x, b, n - s, s); // Recursively sort non-partition-elements if ((s = b - a) > 1) sort1(x, off, s); if ((s = d - c) > 1) sort1(x, n - s, s);}/** * Swaps x[a] with x[b]. */private static void swap(int x[], int a, int b) {int t = x[a]; x[a] = x[b]; x[b] = t;}/** * Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)]. */private static void vecswap(int x[], int a, int b, int n) {for (int i = 0; i < n; i++, a++, b++) swap(x, a, b);}/** * Returns the index of the median of the three indexed integers. */private static int med3(int x[], int a, int b, int c) {return (x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a) : (x[b] > x[c] ? b : x[a] > x[c] ? c : a));}
1.1.2、分析
（1）数组长度小于7，那么排序时基于基本的插入排序算法（2）数组长度大于7，那么在使用的优化后的快速排序，对应数组长度在7和40之间的数组，取的切分元素相对来说简单点
1.2、JDK1.7
1.2.1、源码：
public static void sort(int[] a) {DualPivotQuicksort.sort(a);}// 下面方法来自：java.util.DualPivotQuicksort#sort(int[])public static void sort(int[] a) {sort(a, 0, a.length - 1);}/** * If the length of an array to be sorted is less than this * constant, Quicksort is used in preference to merge sort. */private static final int QUICKSORT_THRESHOLD = 286;/** * The maximum number of runs in merge sort. */private static final int MAX_RUN_COUNT = 67;/** * The maximum length of run in merge sort. */private static final int MAX_RUN_LENGTH = 33;public static void sort(int[] a, int left, int right) {// Use Quicksort on small arrays if (right - left < QUICKSORT_THRESHOLD) {sort(a, left, right, true); return; } /* * Index run[i] is the start of i-th run * (ascending or descending sequence). */ int[] run = new int[MAX_RUN_COUNT + 1]; int count = 0; run[0] = left; // Check if the array is nearly sorted for (int k = left; k < right; run[count] = k) {if (a[k] < a[k + 1]) {// ascending while (++k <= right && a[k - 1] <= else="" if=""> a[k + 1]) {// descending while (++k < = right="" k="" -="">= a[k]); for (int lo = run[count] - 1, hi = k; ++lo < --hi; ) {int t = a[lo]; a[lo] = a[hi]; a[hi] = t; } } else {// equal for (int m = MAX_RUN_LENGTH; ++k <= right && a[k - 1] == a[k]; ) {if (--m == 0) {sort(a, left, right, true); return; } } } /* * The array is not highly structured, * use Quicksort instead of merge sort. */ if (++count == MAX_RUN_COUNT) {sort(a, left, right, true); return; } } // Check special cases if (run[count] == right++) {// The last run contains one element run[++count] = right; } else if (count == 1) {// The array is already sorted return; } /* * Create temporary array, which is used for merging. * Implementation note: variable "right" is increased by 1. */ int[] b; byte odd = 0; for (int n = 1; (n <<= 1) < count; odd ^= 1); if (odd == 0) {b = a; a = new int[b.length]; for (int i = left - 1; ++i < right; a[i] = b[i]); } else {b = new int[a.length]; } // Merging for (int last; count > 1; count = last) {for (int k = (last = 0) + 2; k <= count; k += 2) {int hi = run[k], mi = run[k - 1]; for (int i = run[k - 2], p = i, q = mi; i < hi; ++i) {if (q >= hi || p < mi && a[p] <= else="" if="" count="" for="" int="" i="right," lo="run[count" -="" --i="">= lo; b[i] = a[i] ); run[++last] = right; } int[] t = a; a = b; b = t; }}/** * Sorts the specified range of the array by Dual-Pivot Quicksort. * * @param a the array to be sorted * @param left the index of the first element, inclusive, to be sorted * @param right the index of the last element, inclusive, to be sorted * @param leftmost indicates if this part is the leftmost in the range */private static void sort(int[] a, int left, int right, boolean leftmost){}
在JDK7中，排序使用的双轴快速排序，其要比传统的单轴排序要快
双轴快速排序：如果数组的长度小于QUICKSORT_THRESHOLD的话就会使用这个双轴快速排序，而这个值是286
if (right - left < QUICKSORT_THRESHOLD) {sort(a, left, right, true); return;}
1.3、JDK1.8
1.3.1、源码
public static void sort(int[] a) {DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);}
DualPivotQuicksort.sort方法
private static final int QUICKSORT_THRESHOLD = 286;static void sort(int[] a, int left, int right, int[] work, int workBase, int workLen) {// Use Quicksort on small arrays，QUICKSORT_THRESHOLD为286，当要排序区间小于286时，发现调用了本类的重载sort方法 if (right - left < QUICKSORT_THRESHOLD) {sort(a, left, right, true); return; } /** * run[i] 意味着第i个有序数列开始的位置，（升序或者降序） **/ int[] run =new int[MAX_RUN_COUNT + 1]; int count=0; run[0] = left; // 检查数组是不是已经接近有序状态 for(int k = left; k < right; run[count] = k) {if(a[k] < a[k + 1]){// 升序 while(++k <= right && a[k - 1] <= else=""> a[k + 1]) {// 降序 while(++k <=right k="" -="">= a[k]); //如果是降序的，找出k之后，把数列倒置 for (int lo = run[count],hi = k;++lo < --hi) {int t = a[lo]; a[lo] = a[hi]; a[hi] = t; } } else {// 相等 for(int m = MAX_RUN_LENGTH; ++k <=right && a[k - 1] == a[k];) {// 数列中有至少MAX_RUN_LENGTH的数据相等的时候，直接使用快排。 // 这里为什么这么处理呢？ if(--m == 0){sort(a, left, right, true); return; } } } /** * 数组并非高度有序，使用快速排序,因为数组中有序数列的个数超过了MAX_RUN_COUNT */ if(++count == MAX_RUN_COUNT) {sort(a, left, right, true); return; } } //检查特殊情况 if(run[count] == right++){// 最后一个有序数列只有最后一个元素 run[++count] =right; // 那给最后一个元素的后面加一个哨兵 } else if(count == 1) {// 整个数组中只有一个有序数列，说明数组已经有序啦，不需要排序了 return; } /** * 创建合并用的临时数组。 * 注意： 这里变量right被加了1，它在数列最后一个元素位置+1的位置 * 这里没看懂，没发现后面的奇数处理和偶数处理有什么不同 */ int[] b; byte odd=0; for(int n=1; (n <<= 1) < count; odd ^=1); if(odd == 0) {b=a;a= new int[b.length]; for(int i=left -1; ++i < right; a[i] = b[i]); } else {b=new int[a.length]; } // 合并 // 最外层循环，直到count为1，也就是栈中待合并的序列只有一个的时候，标志合并成功 // a 做原始数组，b 做目标数组 for(int last; count > 1; count = last) {// 遍历数组，合并相邻的两个升序序列 for(int k = (last = 0) + 2; k <= count; k += 2) {// 合并run[k-2] 与 run[k-1]两个序列 int hi = run[k], mi = run[k - 1]; for(int i = run[k - 2], p = i,q = mi; i < hi; ++i){// 这里我给源码加了一个括号，这样好理解一点。 之前总觉得它会出现数组越界问题， // 后来加了这个括号之后发现是没有问题的 if(q >= hi || (p < mi && a[p] < = else="" count="" int="" i="right," lo="run[count" --i="">= lo; b[i] = a[i]); run[++last] = right; } //临时数组，与原始数组对调，保持a做原始数组，b 做目标数组 int[] t = a; a = b; b = t; }}int length = right - left + 1;// INSERTION_SORT_THRESHOLD为47，发现当要排序的个数小于47个时，采用插入排序，采用了哨兵方法，对于新元素从他前一个一个一个比较// Use insertion sort on tiny arraysif (length < INSERTION_SORT_THRESHOLD) {if (leftmost) {/* * Traditional (without sentinel) insertion sort, * optimized for server VM, is used in case of * the leftmost part. */ for (int i = left, j = i; i < right; j = ++i) {int ai = a[i + 1]; while (ai < a[j]) {a[j + 1] = a[j]; if (j-- == left) {break; } } a[j + 1] = ai; } } else {/** * 首先跨过开头的升序的部分 */ do {if(left > right) {return; } }while(a[++left] >= a[left - 1]); /** * 这里用到了成对插入排序方法，它比简单的插入排序算法效率要高一些 * 因为这个分支执行的条件是左边是有元素的 * 所以可以直接从left开始往前查找。 */ for(int k = left; ++left <= k="++left)" int="" a1="" a2="a[left];">=a2 if(a1 < a2) {a2 = a1; a1 = a[left]; } //先把两个数字中较大的那个移动到合适的位置 while(a1 < a[--k]) {a[k + 2] = a[k]; //这里每次需要向左移动两个元素 } a[++k + 1] = a1; //再把两个数字中较小的那个移动到合适的位置 while(a2 < a[--k]) {a[k + 1] = a[k]; //这里每次需要向左移动一个元素 } a[k + 1] = a2; } int last = a[right]; while(last < a[--right]) {a[right + 1] = last; } a[right + 1] = last; } return;}
至于大过INSERTION_SORT_THRESHOLD（47）的，用一种快速排序(双轴快排)的方法：
从数列中挑出五个元素，称为 “基准”（pivot）；重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
总结：插入排序，快速排序，归并排序三种排序的组合
1.4、parallelSort
并行排序，JDK1.8增加的新方法
// 并行排序的最小数组长度private static final int MIN_ARRAY_SORT_GRAN = 1 << 13;public static void parallelSort(int[] a) {int n = a.length, p, g; // 如果数据的长度小于 MIN_ARRAY_SORT_GRAN（1 << 13） if (n <= MIN_ARRAY_SORT_GRAN || // 或者当前并行度级别是 1的话，仍然使用常规的双轴快速排序 (p = ForkJoinPool.getCommonPoolParallelism()) == 1) DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0); else // 否则使用并行排序 new ArraysParallelSortHelpers.FJInt.Sorter (null, a, new int[n], 0, n, 0, ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ? MIN_ARRAY_SORT_GRAN : g).invoke();}
2、搜索：binarySearch
主要用于快速从数组中查找对应的值，如果查找到了，返回的是对应数组的下标的值；如果查询不到则返回负数；
二分查找确保数组一定是有序的，否则可能找不到对应的数据
但是该方法有有一个问题：如果一个数组当中有多个元素，其无法保证匹配的到底是哪一个
// a：我们要搜索的数组，fromIndex：从那里开始搜索，默认是0； toIndex：搜索到何时停止，默认是数组大小// key：我们需要搜索的值 // c：外部比较器private staticint binarySearch0(T[] a, int fromIndex, int toIndex, T key, Comparator c) {// 如果比较器 c 是空的，直接使用 key 的 Comparable.compareTo 方法进行排序 // 假设 key 类型是 String 类型，String 默认实现了 Comparable 接口，就可以直接使用 compareTo 方法进行排序 if (c == null) {// 这是另外一个方法，使用内部排序器进行比较的方法 return binarySearch0(a, fromIndex, toIndex, key); } int low = fromIndex; int high = toIndex - 1; // 开始位置小于结束位置，就会一直循环搜索 while (low <= low="0，high" mid="(low" int="">>> 1; T midVal = a[mid]; // 比较数组中间值和给定的值的大小关系 int cmp = c.compare(midVal, key); // 如果数组中间值小于给定的值，说明我们要找的值在中间值的右边 if (cmp < 0) low = mid + 1; // 我们要找的值在中间值的左边 else if (cmp > 0) high = mid - 1; else // 找到了 return mid; // key found } // 返回的值是负数，表示没有找到 return -(low + 1); // key not found.}
3、数据拷贝：copyOf和copyRange
拷贝整个数组：copyOf
public static int[] copyOf(int[] original, int newLength) { int[] copy = new int[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy;}
拷贝部分数组：copyOfRange
// original 原始数组数据// from 拷贝起点// to 拷贝终点public static char[] copyOfRange(char[] original, int from, int to) {// 需要拷贝的长度 int newLength = to - from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); // 初始化新数组 char[] copy = new char[newLength]; // 调用 native 方法进行拷贝，参数的意思分别是： // 被拷贝的数组、从数组那里开始、目标数组、从目的数组那里开始拷贝、拷贝的长度 System.arraycopy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy;}
基本上调用的是System.arrayCopy方法。
另外在在ArrayList的toArray方法中，其调用的也是Arrays里的copyOf方法，因为ArrayList的底层实现是数组；
4、数组填充：fill
5、数组转换为结婚：asList
public staticListasList(T... a) { return new ArrayList<>(a);}
该方法有以下需要注意的：
其返回的集合不是java.util.ArrayList的实例，而是Array的内部类：java.util.Arrays.ArrayList；java.util.Arrays.ArrayList不能对集合进行增、删操作，其没有实现AbstractList类中的add、remove方法；常见使用方法是：Listlist = new ArrayList<>(Arrays.asList(T...a));，可以将其作为参数传到对应集合的构造方法里面；
二、Collections
为方便集合操作而产生的工具类。
Collections也提供sort和binarySearch方法，其sort方法底层调用就是Arrays.sort方法，而binarySearch底层重写了二分查找算法，实现逻辑和Arrays的二分查找算法一致
1、sort()方法实现
public staticvoid sort(Listlist)
1.1、JDK1.6
1.1.1、源码
// 基本方法public staticvoid sort(Listlist) {Object[] a = list.toArray(); Arrays.sort(a); ListIteratori = list.listIterator(); for (int j=0; j<A.LENGTH; j++)="" {i.next(); i.set((T)a[j]); }}/**********************下面方法未自Arrays***********************/// 调用 Arrays.sort(Object[] a) 排序方法，This algorithm offers guaranteed n*log(n) performance.public static void sort(Object[] a) {Object[] aux = (Object[])a.clone(); mergeSort(aux, a, 0, a.length, 0);}/** * Tuning parameter: list size at or below which insertion sort will be * used in preference to mergesort or quicksort. */private static final int INSERTIONSORT_THRESHOLD = 7;/** * Src is the source array that starts at index 0 * Dest is the (possibly larger) array destination with a possible offset * low is the index in dest to start sorting * high is the end index in dest to end sorting * off is the offset to generate corresponding low, high in src */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++]; }}private static void swap(Object[] x, int a, int b) {Object t = x[a]; x[a] = x[b]; x[b] = t;}
1.2、JDK1.7
1.2.1、源码
public staticvoid sort(Listlist) {Object[] a = list.toArray(); Arrays.sort(a); ListIteratori = list.listIterator(); for (int j=0; j<A.LENGTH; j++)="" {i.next(); i.set((T)a[j]); }}//Arrays.sort方法public static void sort(Object[] a) {if (LegacyMergeSort.userRequested) legacyMergeSort(a); else ComparableTimSort.sort(a);}static final class LegacyMergeSort {private static final boolean userRequested = java.security.AccessController.doPrivileged( new sun.security.action.GetBooleanAction( "java.util.Arrays.useLegacyMergeSort")).booleanValue();}/** To be removed in a future release. */private static void legacyMergeSort(Object[] a) {Object[] aux = a.clone(); mergeSort(aux, a, 0, a.length, 0);}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; ilow && ((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++]; }}/** * Swaps x[a] with x[b]. */private static void swap(Object[] x, int a, int b) {Object t = x[a]; x[a] = x[b]; x[b] = t;}// ComparableTimSort
1.3、JDK1.8
2、集合的最大、最小值
max方法提供了两种实现
// 没有比较器的，那么默认非泛型必须实现了Comparable接口，否则编译的时候会报错，因为其底层是调用Comparable的compareTo方法来进行比较的；// 泛型必须继承Objec且实现Comparable接口；public staticT max(Collection coll) {Iterator i = coll.iterator(); T candidate = i.next(); while (i.hasNext()) {T next = i.next(); if (next.compareTo(candidate) > 0) candidate = next; } return candidate;}// 带比较器，跟不带比较器的类似；public staticT max(Collection coll, Comparator comp) {if (comp==null) return (T)max((Collection) coll); Iterator i = coll.iterator(); T candidate = i.next(); while (i.hasNext()) {T next = i.next(); if (comp.compare(next, candidate) > 0) candidate = next; } return candidate;}
3、多张类型的集合
Collections对原始集合进行了封装，提供了：线程安全的集合、不可变的集合；
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R1ReBn5L-1580104538820)(集合/image/Collections-InnerClass.png)]
3.1、线程安全的集合
线程安全的集合都是以Synchronized开头
SynchronizedListSynchronizedMapSynchronizedSetSynchronizedSortedMapSynchronizedSortedSet
上述线程安全的集合都是通过synchronized代码块来实现的，虽然都是线程安全的，但是在实际应用中避免使用这些类；
3.2、不可变集合
不可变集合都是Unmodifiable开头，这类方法的操作是会从原集合中得到一个不可变的新集合，新集合只能访问，不能修改；否则抛出异常；
UnmodifiableCollection：为只读集合
static class UnmodifiableListextends UnmodifiableCollectionimplements List{public E set(int index, E element) {// 抛出异常 throw new UnsupportedOperationException(); } public void add(int index, E element) {// 抛出异常 throw new UnsupportedOperationException(); } public E remove(int index) {// 抛出异常 throw new UnsupportedOperationException(); } public int indexOf(Object o) {return list.indexOf(o);} public int lastIndexOf(Object o) {return list.lastIndexOf(o);} public boolean addAll(int index, Collection c) {// 抛出异常 throw new UnsupportedOperationException(); } @Override public void replaceAll(UnaryOperatoroperator) {// 抛出异常 throw new UnsupportedOperationException(); } @Override public void sort(Comparator c) {// 抛出异常 throw new UnsupportedOperationException(); }}
三、Objects
1、相等
主要有两个方法：deepEquals、equals，其中deepEquals主要是判断数组的，后面equals主要判断基本类型和自定义类型的
public static boolean deepEquals(Object a, Object b) {if (a == b) return true; else if (a == null || b == null) return false; else return Arrays.deepEquals0(a, b);}public static boolean equals(Object a, Object b) {return (a == b) || (a != null && a.equals(b));}
2、判空
Objects.isNull(Object obj)Objects.nonNull(Object obj)Objects.requireNonNull(T obj)Objects.requireNonNull(T obj, String message)Objects.requireNonNull(T obj, SuppliermessageSupplier)
