本文详细解读了JavaArrays类中的六个重要方法：toString、asList、binarySearch、copyOf、copyOfRange以及sort，通过源代码分析和实例演示，帮助读者掌握这些方法的原理和实际应用场景。
我们学习方法不仅需要知道它，更重要的应该是了解它和运用它。既然要了解它，少不了的就是要看它的源代码，所以下面的每个方法我都先附上源代码，根据源代码来学习。
（ 水平有限，源代码解析请包涵。）
目录
Arrays.toString( )
public static String toString(Object[] 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(String.valueOf(a[i]));
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}传入一个Object类型的数组a，首先判断数组a是否为空，为空返回null。定义一个整型变量，存放数组最后一个元素位置，如果没有元素存在，返回[]；如果存在元素，定义一个可变字符串b，头部添一个[， 遍历数组元素添加进b,每个元素中间使用,分隔，如果遍历到最后一个元素，则再后面加上]。
作用：将数组元素按照数组格式显示出来（因为数组无法直接打印出来，默认的toString方法是数组类型@类型地址）
参数：Object[]
返回值：String
运用举例：
int[] numbers = new int[43]; // 保存43个整数值
// 直接打印数组:数组的类型@内存地址
System.out.println(numbers);// l [I@15db9742
// 通过Arrays数组工具类，打印数组的内容
System.out.println(Arrays.toString(numbers));Arrays.asList( )
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}通过源代码，可以看出是将数组转换成一个新的List
作用：将数组转换成一个新的List
参数：数组
返回值：列表
运用举例：
int[] arr = {1,2,3};
List<int[]> ints = Arrays.asList(arr);
System.out.println(ints);
Arrays.binarySearch( )
public static int binarySearch(Object[] a, Object key) {
return binarySearch0(a, 0, a.length, key);
}第一层是调用binarySearch0方法，传入数组a、a的长度、目标元素key。
private static int binarySearch0(Object[] a, int fromIndex, int toIndex,
Object key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
@SuppressWarnings("rawtypes")
Comparable midVal = (Comparable)a[mid];
@SuppressWarnings("unchecked")
int cmp = midVal.compareTo(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.
}第二层，重载binarySearch0方法，传入数组，开始下标位置，结束下标位置，目标元素。
while条件低位下标值小于高位下标，计算中间值mid,如果目标元素比中间元素大，则向mid的右边查找；否则，向mid的左边数组查找。当存在元素时，返回下标mid，不存在则返回 -(low+1)
作用：二分查找
参数：Object[] Object类型目标元素
返回值：int
运用举例：
int[] numbers = {2,3,4,6,7,56};
// 二分查找(前提是数组必须有序)
// 返回结果:如果元素存在，则返回该元素的下标;如果不存在,
int ret = Arrays.binarySearch(numbers, 17);
System.out.println(ret);
Arrays.copyOf( )
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}第一层，传入数组、int类型变量，调用copyOf()方法。
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;
}第二层，重载copyOf()方法，传入原始数组，复制元素数量，指定复制数组类型。通过三元条件运算符，它根据newType的类型创建一个新的数组copy。如果newType是Object[].class，则创建一个Object类型的新数组；否则复制为指定的类型的数组。
作用：将原始数组的元素复制到新数组中
参数：原始数组，要复制的元素数量
返回值：数组
运用举例：
// 数组的复制
String[] heros = { "ss", "gg", "dd", "aa", "xx", "zz" };
String[] copyHeros1 = Arrays.copyOf(heros, 3);// 复制前3个
String[] copyHeros2 = Arrays.copyOf(heros, heros.length);// 复制所有元素
System.out.println(Arrays.toString(copyHeros1));
System.out.println(Arrays.toString(copyHeros2));
Arrays.copyOfRange( )
public static <T> T[] copyOfRange(T[] original, int from, int to) {
return copyOfRange(original, from, to, (Class<? extends T[]>) original.getClass());
}第一层，调用copyOfRange()方法，传入数组，复制开始位置变量，复制结束位置变量。
public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}第二层，重载copyOfRange()方法，传入原始数组，复制开始位置，复制结束位置，指定复制数组类型。计算新数组的长度，判断长度是否小于0，是抛出异常。否，复制为新的数组。
作用：将原始数组的元素复制到新数组中
参数：原始数组，复制开始位置，复制结束位置，指定复制数组类型
返回值：数组
运用举例：
// 数组的复制
String[] heros = { "ss", "gg", "dd", "aa", "xx", "zz" };
String[] copyHeros = Arrays.copyOf(heros, 3，5);// 复制3到5之前元素
System.out.println(Arrays.toString(copyHeros));
Arrays.fill( )
public static void fill(Object[] a, Object val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}传入一个Object类型的数组a和Object类型的变量val，for循环遍历数组a将a的所有元素填充为 val。
作用：将数组所有元素填充为指定元素
参数：Object[] Object变量
返回值：没有返回值
运用举例：
//数组的填充
String[] names = new String[345]; //创建数组
Arrays.fill(names,"T");//将指定数组names的所有元素填充为"T"
System.out.println(Arrays.toString(names)) ;
Arrays.sort( )
public static void sort(int[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}第一层，调用sort方法，传入int[]数组a。
static void sort(int[] a, int left, int right,
int[] work, int workBase, int workLen) {
// 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] <= a[k]);
} else if (a[k] > a[k + 1]) { // descending
while (++k <= right && a[k - 1] >= 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;
}
}
}第二层，调用了 DualPivotQuicksort 中的 sort 方法。判断数组长度是否超过快排阈值，如果超过，则判断数组的有序程度进行升序排序，否则直接调用快排方法。
作用：数组排序
参数：原始Int[]数组，
返回值：没有返回值
运用举例：
int[] numbers = { 3, 4, 56, 6, 2, 7 };
// 排序
Arrays.sort(numbers); // [2,3,4,6,7,56]
System.out.println(Arrays.toString(numbers));
245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
