文章目錄
- Arrays類概述
- 常用方法
- 排序sort
- 搜索binarySearch
- 比較equals
- 填充fill
- 賦值copyOf
- 將陣列轉換成串列asList
- 獲取哈希碼hashCode
- toString
Arrays類概述
Arrays類在原始碼中的宣告：
/**
* This class contains various methods for manipulating arrays (such as
* sorting and searching). This class also contains a static factory
* that allows arrays to be viewed as lists.
*
* <p>The methods in this class all throw a {@code NullPointerException},
* if the specified array reference is null, except where noted.
*
* <p>The documentation for the methods contained in this class includes
* briefs description of the <i>implementations</i>. Such descriptions should
* be regarded as <i>implementation notes</i>, rather than parts of the
* <i>specification</i>. Implementors should feel free to substitute other
* algorithms, so long as the specification itself is adhered to. (For
* example, the algorithm used by {@code sort(Object[])} does not have to be
* a MergeSort, but it does have to be <i>stable</i>.)
*
* <p>This class is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*/
public class Arrays
Arrays類可以看做是一個陣列工具類，它包含了用于操作陣列的各種方法（如排序和搜索）， 該類還包含一個靜態工廠，可以將陣列視為串列，
如果指定的陣列參考為空，則該類中的方法都拋出一個NullPointerException ，除非另有說明，
常用方法
Arrays類中的排序呼叫DualPivotQuicksort類中的排序方法實作，
關于DualPivotQuicksort類的宣告如下：
/**
* This class implements the Dual-Pivot Quicksort algorithm by
* Vladimir Yaroslavskiy, Jon Bentley, and Josh Bloch. The algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* All exposed methods are package-private, designed to be invoked
* from public methods (in class Arrays) after performing any
* necessary array bounds checks and expanding parameters into the
* required forms.
*/
final class DualPivotQuicksort
DualPivotQuicksort被稱為雙軸快速排序，它匯集了多種排序演算法，包括 優化后的歸并排序（Timsort）、插入排序，成對插入排序、單軸快速排序，雙軸快速排序
、計數排序，
DualPivotQuicksort原始碼見：DualPivotQuicksort原始碼
排序sort
它提供了對int、long、short、char、byte、float、double、object型陣列的排序方法，
//按照數字順序排列指定的陣列，
public static void sort(int[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
//在指定范圍對指定陣列進行升序排序， 要排序的范圍從索引fromIndex （包括）擴展到索引toIndex（不包括）， 如果fromIndex == toIndex ，要排序的范圍是空的，
public static void sort(int[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
//按照數字順序排列指定的陣列，
public static void sort(long[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
//在指定范圍對指定陣列進行升序排序， 要排序的范圍從索引fromIndex （包括）擴展到索引toIndex（不包括）， 如果fromIndex == toIndex ，要排序的范圍是空的，
public static void sort(long[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
//按照數字順序排列指定的陣列，
public static void sort(short[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
//在指定范圍對指定陣列進行升序排序， 要排序的范圍從索引fromIndex （包括）擴展到索引toIndex（不包括）， 如果fromIndex == toIndex ，要排序的范圍是空的，
public static void sort(short[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
//按照數字順序排列指定的陣列，
public static void sort(char[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
//在指定范圍對指定陣列進行升序排序， 要排序的范圍從索引fromIndex （包括）擴展到索引toIndex（不包括）， 如果fromIndex == toIndex ，要排序的范圍是空的，
public static void sort(char[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
//按照數字順序排列指定的陣列，
public static void sort(byte[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1);
}
//在指定范圍對指定陣列進行升序排序， 要排序的范圍從索引fromIndex （包括）擴展到索引toIndex（不包括）， 如果fromIndex == toIndex ，要排序的范圍是空的，
public static void sort(byte[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1);
}
//按照數字順序排列指定的陣列，
public static void sort(float[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
//在指定范圍對指定陣列進行升序排序， 要排序的范圍從索引fromIndex （包括）擴展到索引toIndex（不包括）， 如果fromIndex == toIndex ，要排序的范圍是空的，
public static void sort(float[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
//按照數字順序排列指定的陣列，
public static void sort(double[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
//在指定范圍對指定陣列進行升序排序， 要排序的范圍從索引fromIndex （包括）擴展到索引toIndex（不包括）， 如果fromIndex == toIndex ，要排序的范圍是空的，
public static void sort(double[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
除此之外，Arrays中還提供了許多其他型別的排序方法，如并行排序、歸并排序等，這里不再一一例舉，
搜索binarySearch
Arrays提供binarySearch二分查找方法，binarySearch()方法提供了多種多載形式，用于滿足各種型別陣列（int、long、short、char、byte、float、double、object型）的查找需要，
// 使用二叉搜索演算法搜索指定的int陣列的指定值， 在進行此呼叫之前，必須對陣列進行排序（如sort(int[])方法）， 如果沒有排序，結果是未定義的，
public static int binarySearch(int[] a, int key) {
return binarySearch0(a, 0, a.length, key);
}
//使用二叉搜索演算法在指定陣列的指定范圍內搜索指定值，
public static int binarySearch(int[] a, int fromIndex, int toIndex,
int key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
private static int binarySearch0(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;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
這里只例舉了int型陣列的搜索，其他型別的陣列搜索比較類似，
比較equals
Arrays中也提供了equals方法，比較兩者是否相等，
equals()方法提供了多種多載形式，用于滿足各種型別陣列（int、long、short、char、byte、float、double、object型）的需要，
public static boolean equals(int[] a, int[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; i<length; i++)
if (a[i] != a2[i])
return false;
return true;
}
填充fill
Arrays中還提供了fill方法，用于將指定值填充在指定陣列的每個元素（或指定范圍的所有元素），
fill()方法提供了多種多載形式，用于滿足各種型別陣列（int、long、short、char、byte、float、double、object型）的需要，
//將指定的int值分配給指定的int陣列的每個元素，
public static void fill(int[] a, int val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
// 將指定的int值分配給指定的int陣列的指定范圍的每個元素， 要填充的范圍從索引fromIndex擴展到索引toIndex， （如果fromIndex==toIndex ，要填充的范圍是空的，）
public static void fill(int[] a, int fromIndex, int toIndex, int val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
賦值copyOf
copyOf方法用于復制指定陣列，得到原始陣列的副本，截斷或填充空值以獲取指定的長度 ，
copyOf()方法提供了多種多載形式，用于滿足各種型別陣列（int、long、short、char、byte、float、double、object型）的需要，
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
將陣列轉換成串列asList
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
獲取哈希碼hashCode
hashCode用于根據指定陣列的內容回傳哈希碼，
hashCode()方法提供了多種多載形式，用于滿足各種型別陣列（int、long、short、char、byte、float、double、object型）的需要，
public static int hashCode(long a[]) {
if (a == null)
return 0;
int result = 1;
for (long element : a) {
int elementHash = (int)(element ^ (element >>> 32));
result = 31 * result + elementHash;
}
return result;
}
toString
回傳指定陣列的內容的字串表示形式， 字串表示由陣列元素的串列組成，括在方括號（ “[]” ）中， 相鄰的元素由字符", "分隔（逗號后跟一個空格），
toString()方法提供了多種多載形式，用于滿足各種型別陣列（int、long、short、char、byte、float、double、object型）的需要，
public static String toString(long[] 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(", ");
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/399595.html
標籤：其他