总体方法一览

image-20220830222510615

asList

这个方法可以将传入的多个数字转换成一个List集合

注意，这里得到的List只适合遍历，不能增删，否则会报UnsupportedOperationException异常

参考文章：Arrays.asList() 详解_开着奥迪卖小猪的博客-CSDN博客_arrays.aslist

1
2
3
4
5
6
7
8
// 将{1, 2, 3}装换成一个List集合
List<Integer> arrayList = Arrays.asList(1, 2, 3);
// 遍历List集合
for (Integer integer : arrayList) {
	System.out.print(integer + " ");
}
// 结果
// 1 2 3

sort

功能划分

Arrays类给我们提供了非常多的sort重载方法

根据功能划分可以分为四组

第一组：对整个数组进行默认排序，是升序排序

第二组：对整个数组进行自定义排序

第三组：指定数组的排序范围进行默认排序，也是升序排序

第四组：指定数组的排序范围进行自定义排序

image-20220831092514623

第一组

对整个数组进行升序排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 定义一个包含10个元素的随机数值在0~99之间的数组
Random random = new Random();
int[] arrays = new int[10];
for (int i = 0; i < arrays.length; i++) {
	arrays[i] = random.nextInt(100);
}
// 排序前
System.out.println("排序前: ");
for (int array : arrays) {
	System.out.print(array + " ");
}
System.out.println();
// 排序
Arrays.sort(arrays);
// 排序后
System.out.println("排序后: ");
for (int array : arrays) {
	System.out.print(array + " ");
}
// 输出结果
// 排序前: 
// 21 21 61 97 37 87 65 10 34 49 
// 排序后: 
// 10 21 21 34 37 49 61 65 87 97

第二组

对整个数组进行降序排序

注意使用自定义排序的数组元素必须是基本数据类型对应的包装类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 定义一个包含10个元素的随机数值在0~99之间的数组
Random random = new Random();
Integer[] arrays = new Integer[10];
for (int i = 0; i < arrays.length; i++) {
	arrays[i] = random.nextInt(100);
}
// 排序前
System.out.println("排序前: ");
for (Integer array : arrays) {
	System.out.print(array + " ");
}
System.out.println();
// 排序
Arrays.sort(arrays, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
	return o2 - o1;
   	}
});
// 排序后
System.out.println("排序后: ");
for (Integer array : arrays) {
	System.out.print(array + " ");
}
// 结果
// 排序前: 
// 46 23 46 6 88 66 30 72 61 67 
// 排序后: 
// 88 72 67 66 61 46 46 30 23 6

第三组

对0~4位的元素进行升序排序,注意传参为左闭右开[fromIndex, toIndex)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 定义一个包含10个元素的随机数值在0~99之间的数组
Random random = new Random();
int[] arrays = new int[10];
for (int i = 0; i < arrays.length; i++) {
	arrays[i] = random.nextInt(100);
}
// 排序前
System.out.println("排序前: ");
for (int array : arrays) {
	System.out.print(array + " ");
}
System.out.println();
// 对0~4位的元素进行升序排序
Arrays.sort(arrays, 0, 5);
// 排序后
System.out.println("排序后: ");
for (int array : arrays) {
	System.out.print(array + " ");
}
// 结果
// 排序前: 
// 45 12 31 15 75 84 46 42 43 79 
// 排序后: 
// 12 15 31 45 75 84 46 42 43 79

第四组

对0~4位的元素进行降序排序,注意传参为左闭右开[fromIndex, toIndex)

注意使用自定义排序的数组元素必须是基本数据类型对应的包装类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 定义一个包含10个元素的随机数值在0~99之间的数组
Random random = new Random();
int[] arrays = new int[10];
for (int i = 0; i < arrays.length; i++) {
	arrays[i] = random.nextInt(100);
}
// 排序前
System.out.println("排序前: ");
for (int array : arrays) {
	System.out.print(array + " ");
}
System.out.println();
// 排序
Arrays.sort(arrays, 0, 5, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
	return o2 - o1;
   	}
});
// 排序后
System.out.println("排序后: ");
for (int array : arrays) {
	System.out.print(array + " ");
}
// 结果
// 排序前: 
// 61 54 34 86 90 13 93 7 71 18 
// 排序后: 
// 90 86 61 54 34 13 93 7 71 18

binarySearch

功能划分

这个可以对有序数组进行二分查找，找到返回索引下标，没有找到则返回一个负数

同样可以分为四组

​ 第一组：从整个数组a中使用二分查找算法查找key

​ 第一组：指定比较器Comparator从整个数组a中查找key

​ 第一组：从数组的[fromIndex, toIndex)中查找key

​ 第一组：指定比较器Comparator从数组的[fromIndex, toIndex)中查找key

image-20220831091200747

第一组

从整个数组中查找指定元素

1
2
3
4
5
6
7
8
int[] arrays = new int[5]{0, 1, 2, 3, 4 ,5};
// 查找5
System.out.println(Arrays.binarySearch(arrays, 5));
// 查找9
System.out.println(Arrays.binarySearch(arrays, 7));
// 输出
// 5
// -7

第二组

通过指定比较器Comparator从整个数组a中查找key

这个比较器比较的是midVal和key的大小,可以通过重写比较器Comparator的compare方法来自定义比较规则

image-20220831094106263

这里给大家演示，就使用默认比较规则好了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int[] arrays = new int[5]{0, 1, 2, 3, 4 ,5};
// 查找5
System.out.println(Arrays.binarySearch(arrays, 5, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
	return o1 - o2;
	}
}));
// 查找9
System.out.println(Arrays.binarySearch(arrays, 5, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
	return o1 - o2;
	}
}));
// 输出
// 5
// -7

第三组

从数组的[fromIndex, toIndex)中查找key

1
2
3
4
5
6
7
8
Integer[] arrays = new Integer[]{0, 1, 2, 3, 4 ,5};
// 从索引范围[0,2)中查找元素2
System.out.println(Arrays.binarySearch(arrays, 0, 3, 2));
// 从索引范围[0, 1)中查找元素2
System.out.println(Arrays.binarySearch(arrays, 0, 1, 2));
// 输出
// 2
// -2

第四组

指定比较器Comparator从数组的[fromIndex, toIndex)中查找key

这里给大家演示，就使用默认比较规则好了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Integer[] arrays = new Integer[]{0, 1, 2, 3, 4 ,5};
// 从索引范围[0,2)中查找元素2
System.out.println(Arrays.binarySearch(arrays, 0, 3, 2, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
	return o2 -o1;
	}
}));
// 从索引范围[0, 1)中查找元素2
System.out.println(Arrays.binarySearch(arrays, 0, 1, 2, new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		return o2 - o1;
	}
}));
// 输出
// 2
// -2

toString

返回数组的字符串形式

image-20220831095321631

这里演示int[]类型的数组转字符串，其他类型大同小异

1
2
3
4
5
Integer[] arrays = new Integer[]{0, 1, 2, 3, 4 ,5};
// 输出数组的toString字符串
System.out.println(Arrays.toString(arrays));
// 输出
// [0, 1, 2, 3, 4, 5]

fill

功能划分

可以替换数组中的原来的元素为val

根据功能可以划分为两组

第一组：替换整个数组元素为val

第二组：替换数组区间[fromIndex, toIndex)的元素为val

image-20220831095718909

第一组

替换整个数组元素为val

1
2
3
4
5
6
7
8
Integer[] arrays = new Integer[]{0, 1, 2, 3, 4 ,5};
System.out.println(Arrays.toString(arrays));
// 替换整个数组的全部元素为888
Arrays.fill(arrays, 888);
System.out.println(Arrays.toString(arrays));
// 结果
// [0, 1, 2, 3, 4, 5]
// [888, 888, 888, 888, 888, 888]

第二组

替换数组区间[fromIndex, toIndex)的元素为val

1
2
3
4
5
6
7
8
Integer[] arrays = new Integer[]{0, 1, 2, 3, 4 ,5};
System.out.println(Arrays.toString(arrays));
// 替换整个数组区间在[0,3)的元素为888
Arrays.fill(arrays, 888);
System.out.println(Arrays.toString(arrays));
// 结果
// [0, 1, 2, 3, 4, 5]
// [888, 888, 888, 3, 4, 5]

copyOf

可以将一个数组拷贝到另一个数组，返回值为新数组

这个方法是浅拷贝

功能划分

根据功能可以划分为两组

  • 第一组：指定拷贝的数组和新数组的长度

根据拷贝的数组和新数组的长度关系，可以分为三种情况

  1. newLength <= original

    拷贝部分数组元素到新数组

  2. newLength > original

    拷贝全部数组元素到新数组同时多余位置补对应元素的初始值

  3. newLength < 0时，会抛出异常NegativeArraySizeException

  • 第二组：指定拷贝的数组、新数组的长度和新数组元素的类型

    这个新数组元素的类型和拷贝的数组元素类型必须要兼容

image-20220831102052148

第一组

分别演示三种情况

第一种情况

newLength <= original

拷贝部分数组元素到新数组

1
2
3
4
5
6
7
8
Integer[] arrays = new Integer[]{0, 1, 2, 3, 4 ,5};
System.out.println("arrays: " + Arrays.toString(arrays));
// 拷贝
Integer[] copyArrays = Arrays.copyOf(arrays, 5);
System.out.println("copyArrays: " + Arrays.toString(copyArrays));
// 结果
// arrays: [0, 1, 2, 3, 4, 5]
// copyArrays: [0, 1, 2, 3, 4]

第二种情况

newLength > original

拷贝全部数组元素到新数组同时多余位置补对应元素的初始值

1
2
3
4
5
6
7
Integer[] arrays = new Integer[]{0, 1, 2, 3, 4 ,5};
System.out.println("arrays: " + Arrays.toString(arrays));
// 拷贝
Integer[] copyArrays = Arrays.copyOf(arrays, 10);
System.out.println("copyArrays: " + Arrays.toString(copyArrays));
arrays: [0, 1, 2, 3, 4, 5]
copyArrays: [0, 1, 2, 3, 4, 5, null, null, null, null]

第三种情况

newLength < 0时，会抛出异常NegativeArraySizeException

1
2
3
4
5
6
7
8
9
10
11
12
13
Integer[] arrays = new Integer[]{0, 1, 2, 3, 4 ,5};
System.out.println("arrays: " + Arrays.toString(arrays));
// 拷贝
Integer[] copyArrays = Arrays.copyOf(arrays, -1);
System.out.println("copyArrays: " + Arrays.toString(copyArrays));
// 输出结果
// arrays: [0, 1, 2, 3, 4, 5]
// Exception in thread "main" java.lang.NegativeArraySizeException
// 	at java.lang.reflect.Array.newArray(Native Method)
//	at java.lang.reflect.Array.newInstance(Array.java:75)
//	at java.util.Arrays.copyOf(Arrays.java:3212)
//	at java.util.Arrays.copyOf(Arrays.java:3181)
//	at array.arrays.test01.main(test01.java:51)

第二组

指定拷贝的数组、新数组的长度和新数组元素的类型

这个新数组元素的类型和拷贝的数组元素类型必须要兼容

1
2
3
4
5
6
7
8
String[] arrays = new String[]{"鸡", "你", "太", "美"};
System.out.println("arrays: " + Arrays.toString(arrays));
// 指定新数组类型为String[]
String[] copyArrays = Arrays.copyOf(arrays, 4, String[].class);
System.out.println("copyArrays: " + Arrays.toString(copyArrays));
// 输出结果
// arrays: [鸡, 你, 太, 美]
// copyArrays: [鸡, 你, 太, 美]

copyOfRange

这个和copyOf差不多功能，但是它可以指定拷贝原数组的范围

这个方法是浅拷贝

有如下重载形式

image-20220831105230502

这里只演示一个，其他的大同小异，万变不离其宗

1
2
3
4
5
6
7
8
String[] arrays = new String[]{"鸡", "你", "太", "美"};
System.out.println("arrays: " + Arrays.toString(arrays));
// 拷贝arrays索引为[1, 4)这段数组元素
String[] copyArrays = Arrays.copyOfRange(arrays, 1, 4);
System.out.println("copyArrays: " + Arrays.toString(copyArrays));
// 输出结果
// arrays: [鸡, 你, 太, 美]
// copyArrays: [你, 太, 美]