我们学习方法不仅需要知道它,更重要的应该是了解它和运用它。既然要了解它,少不了的就是要看它的源代码,所以下面的每个方法我都先附上源代码,根据源代码来学习。
( 水平有限,源代码解析请包涵。)
目录
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));