Java中Arrays数组工具类的使用全解
本文几乎涵盖了所有的Arrays工具类（基于Java 11）的方法以及使用用例，一站式带你了解Arrays类的用法,希望对大家有帮助。
码字不易，三连支持一下吧😃
Arrays数组工具类
方法一览表
| 方法名 | 简要描述 |
|---|---|
| asList() | 返回由指定数组支持的固定大小的列表。 |
| sort() | 将数组排序（升序） |
| parallelSort() | 将指定的数组按升序排序 |
| binarySearch() | 使用二分搜索法快速查找指定的值（前提是数组必须是有序的） |
| compare() | 按字典顺序比较两个数组 |
| compareUnsigned() | 按字典顺序比较两个数组，将数字元素处理为无符号 |
| copyOf() | 填充复制数组 |
| copyOfRange() | 将数组的指定范围复制到新数组 |
| equals() | 比较两个数组 |
| deepEquals() | 比较两个数组深度 |
| toString() | 将数组转换为字符串 |
| deepToString() | 将一个多维数组转换为字符串 |
| fill() | 将指定元素填充给数组每一个元素 |
| mismatch() | 查找并返回两个数组之间第一个不匹配的索引，如果未找到则返回-1 |
| parallelPrefix() | 使用提供的函数对数组元素进行操作 |
| parallelSetAll() | 使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素 |
| setAll() | 使用提供的生成器函数设置指定数组的所有元素以计算每个元素 |
快速定位详细操作
接下来我用代码一一举例演示。
asList()
功能：返回由指定数组支持的固定大小的列表
参数：asList(T… a)
返回值：一个列表
代码示例：
@Test
public void asListTest() {
List<String> ss = Arrays.asList("hello", "world");
// List<String> ss1 = Arrays.asList("hello", "world",1); 报错，类型必须一直（泛型）
System.out.println(ss); //[hello, world]
// ss.add("java"); //UnsupportedOperationException 会报错
// ss.remove(1); //UnsupportedOperationException 会报错
System.out.println(ss.get(0)); //hello
ss.set(0, "java");
System.out.println(ss); //[java, world]
}
注意
将这一数组转换为列表后，对应的列表是不支持添加和删除操作的，否则会报错
但可以修改和获取元素
toString() 和 deepToString()
功能：将数组转换为字符串
参数：待转化数组
返回值：转化后的字符串
代码示例：
@Test
public void toStringTest() {
String[] str = {"java", "hello", "javascript"};
String[][] strs = {{"a", "b"}, {"c"}, {"d", "e"}};
System.out.println(Arrays.toString(str));
//[java, hello, javascript]
System.out.println(Arrays.toString(strs));
//[[Ljava.lang.String;@4563e9ab, [Ljava.lang.String;@11531931, [Ljava.lang.String;@5e025e70]
//普通的toString()方法只转化一层，内层还是地址值
System.out.println(Arrays.deepToString(strs));
//可以深度转换
//[[a, b], [c], [d, e]]
}
sort() 和 parallelSort()
功能：都是将数组排序（默认升序，支持lambda，泛型）
参数：
- sort(Object[] a[, int fromIndex, int toIndex])
- 或者sort(T[] a[, int fromIndex, int toIndex,] Comparator<? super T> c)
- parallelSort(Object[] a[, int fromIndex, int toIndex])
- 或者parallelSort(T[] a[, int fromIndex, int toIndex,] Comparator<?
super T> c)
返回值：无
代码示例：
@Test
public void sortTest() {
String[] str = {"abc", "add", "java", "hello", "javascript"};
int[] ii = {1, 8, 99, 222, 35};
System.out.println(Arrays.toString(str));
System.out.println(Arrays.toString(ii));
//单参数情况
//Arrays.sort(str); 默认全排，字母会按照字母表顺序
//Arrays.sort(ii);
//System.out.println(Arrays.toString(str)); //[abc, add, hello, java, javascript]
//System.out.println(Arrays.toString(ii)); //[1, 8, 35, 99, 222]
//多参数情况
//Arrays.sort(str,2,4); 只排列指定范围内的
//Arrays.sort(ii,2,4);
//System.out.println(Arrays.toString(str)); //[abc, add, hello, java, javascript]
//System.out.println(Arrays.toString(ii)); //[1, 8, 99, 222, 35]
//可传入lambda表达式(多参数情况可指定开始结束位置)
// Arrays.sort(str, (a, b) -> b.compareTo(a)); //降序
// System.out.println(Arrays.toString(str)); //[javascript, java, hello, add, abc]
//parallelSort()方法目前我实验感觉与sort()相差无几，基本相似
Arrays.parallelSort(str);
System.out.println(Arrays.toString(str)); //[abc, add, hello, java, javascript]
Arrays.parallelSort(str,(a,b)->b.compareTo(a));
System.out.println(Arrays.toString(str)); //[javascript, java, hello, add, abc]
}
binarySearch()
功能：使用二分搜索法快速查找指定的值（前提是数组必须是有序的，支持lambda表达式，泛型）
参数：binarySearch(Object[] a[, int fromIndex, int toIndex], Object key)
返回值：有则返回对应下标，无则返回负值
代码示例：
@Test
public void binarySearchTest() {
int[] a = {1, 5, 7, 4, 6, 7, 8, 4, 9, 0};
Arrays.sort(a); //必须先排序
System.out.println(Arrays.toString(a));
//[0, 1, 4, 4, 5, 6, 7, 7, 8, 9]
System.out.println(Arrays.binarySearch(a, 4)); //2
System.out.println(Arrays.binarySearch(a, 11)); //-11
//也可指定范围查找,其查找机制是折半查找，每次缩小一半范围
}
compare() 和 compareUnsigned()
功能：按字典顺序比较两个数组
参数：
- compare(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】,【 Comparator<? super T> cmp】)
返回值：
- 如果第一个和第二个数组相等并且包含相同顺序的相同元素，则值为0 ;
- 如果第一个数组按字典顺序小于第二个数组，则值小于0 ;
- 如果第一个数组按字典顺序大于第二个数组，则值大于0
代码示例：
@Test
public void compareTest() {
int[] a = {1, 2, 3, 4};
int[] b = {1, 2, 3, 4, 5};
int[] c = {1, 2, 3, 4, 5};
String[] s1 = {"java","hello","c++"};
String[] s2 = {"java","hello"};
// System.out.println(Arrays.compare(a,b)); //-1
// System.out.println(Arrays.compare(b,a)); //1
// System.out.println(Arrays.compare(b,c)); //0
System.out.println(Arrays.compare(s1,s2)); //1
//也可划定范围去比较，或者传入lambda
// System.out.println(Arrays.compareUnsigned(s1,s2));//报错
System.out.println(Arrays.compareUnsigned(a,b)); //-1
}
注意
compareUnsigned()只能比较byte(),short(),int(),long()数字型数组，可以划定比较范围，但不支持lambda
copyOf() 和 copyOfRange()
功能：复制填充数组
参数：
- copyOf(int[] original, int newLength)…
- copyOf(T[] original, int newLength)
- copyOfRange(int[] original, int from, int to）…
- copyOfRange(T[] original, int from, int to)
- copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)
返回值：复制填充后的数组
代码示例：
@Test
public void copyOfTest() {
//copyOf
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
int[] arr1 = Arrays.copyOf(arr, 5); //拷贝长度为5，第二个参数为新数组的长度
int[] arr2 = Arrays.copyOf(arr, 15);
System.out.println(Arrays.toString(arr1)); //[1, 2, 3, 4, 5]
System.out.println(Arrays.toString(arr2)); //[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0]
arr[0] = 20; //改变原数组
System.out.println(Arrays.toString(arr)); //原数组改变
System.out.println(Arrays.toString(arr1)); //复制后的数组不变
String[] str = {"java","hello","world"};
String[] str1 = Arrays.copyOf(str,2);
String[] str2 = Arrays.copyOf(str,5);
System.out.println(Arrays.toString(str1)); //[java, hello]
System.out.println(Arrays.toString(str2)); //[java, hello, world, null, null]
//copyOfRange()
int[] arrs = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
int[] arr3 = Arrays.copyOfRange(arrs,2,8); //[3, 4, 5, 6, 7, 8]
int[] arr4 = Arrays.copyOfRange(arrs,5,15); //[6, 7, 8, 9, 0, 0, 0, 0, 0, 0]
System.out.println(Arrays.toString(arr3));
System.out.println(Arrays.toString(arr4));
arrs[6] = 99; //改变原数组
System.out.println(Arrays.toString(arrs)); //[1, 2, 3, 4, 5, 6, 99, 8, 9, 0] 原数组改变
System.out.println(Arrays.toString(arr3)); //[3, 4, 5, 6, 7, 8] 复制后的不会随着改变
}
注意
copyOf()是从原数组0位置开始拷贝指定长度到新数组
copyOfRange()是从原数组中指定范围拷贝到新数组
如果指定长度或者范围超出原数组范围，则超出部分会补上此数据类型的默认值，如String类型会补null，int型会补0
equals()
功能：比较两个数组
参数：
- equals(int[] a,【 int aFromIndex, int aToIndex】, int[] b,【 int bFromIndex, int bToIndex】)…
- equals(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】, Comparator<? super T> cmp)
返回值：boolean
代码示例：
@Test
public void equalsTest() {
int[] a = {1, 2, 3, 4, 5, 6};
int[] b = {6, 5, 3, 4, 2, 1};
System.out.println(Arrays.equals(a, b)); //false
System.out.println(Arrays.equals(a, 2, 3, b, 2, 3)); //指定比较范围 true
}
deepEquals()
功能：比较两个数组的深度
参数：deepEquals(Object[] a1, Object[] a2)
返回值：boolean
代码示例：
@Test
public void deepEqualsTest() {
String[] s1 = {"java", "hello", "c++"};
String[] s2 = {"java", "hello"};
String[] s3 = {"java", "hello", "c++"};
System.out.println(Arrays.deepEquals(s1, s2)); //false
System.out.println(Arrays.deepEquals(s1, s3)); //true
String[][] s4 = {{"hello"}, {"java"}, {"c++"}, {"python"}};
String[][] s5 = {{"hello"}, {"java"}, {"c++"}, {"python"}};
System.out.println(Arrays.deepEquals(s4, s5)); //true
System.out.println(Arrays.equals(s4, s5)); //false
int[] a = {1,2};
int[] b = {1,2};
// System.out.println(Arrays.deepEquals(a,b)); //报错
}
比较equals()和deepEquals()方法
相同点
- 两者都是比较数组是否相等的方法
不同点
- equals默认从头比较到尾，也可以指定范围，但是deepEquals不能指定范围
- deepEquals可以比较多维数组，equals不能
- deepEquals不支持比较基本类型数组，equals支持
fill()
功能：将指定元素填充给数组每一个元素
参数：fill(int[] a, 【int fromIndex, int toIndex】, int val)
返回值：无
代码示例：
@Test
public void fillTest() {
String[] a = {"a", "b", "c", "d", "e", "f"};
System.out.println(Arrays.toString(a)); //[a, b, c, d, e, f]
Arrays.fill(a, "java");
System.out.println(Arrays.toString(a)); //[java, java, java, java, java, java]
String[] b = {"a", "b", "c", "d", "e", "f"};
System.out.println(Arrays.toString(b)); //[a, b, c, d, e, f]
Arrays.fill(b, 2, 5, "java");
System.out.println(Arrays.toString(b)); //[a, b, java, java, java, f]
//默认全填充，也可以指定范围，会改变原数组
}
mismatch()
功能：查找并返回两个数组之间第一个不匹配的索引，如果未找到则返回-1
参数：
- mismatch(int[] a, 【int aFromIndex, int aToIndex】, int[] b,【 int bFromIndex, int bToIndex】)
- mismatch(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】, Comparator<? super T> cmp)
返回值：两个数组之间第一个不匹配的索引，未找到不匹配则返回-1。
代码示例：
@Test
public void mismatchTest() {
String[] s1 = {"java", "c++", "html", "css", "Javascript", "world"};
String[] s2 = {"world", "c++", "html", "css", "Javascript"};
System.out.println(Arrays.mismatch(s1, s2)); //0
System.out.println(Arrays.mismatch(s1, 1, 4, s2, 1, 4)); //-1
System.out.println(Arrays.mismatch(s1, 1, 5, s2, 1, 4)); //3
}
parallelPrefix()
功能：使用提供的函数并行地累积给定数组的每个元素。
参数：
- parallelPrefix(int[] array, 【int fromIndex, int toIndex】, IntBinaryOperator op)
- parallelPrefix(T[] array, 【int fromIndex, int toIndex】, BinaryOperator op)
返回值：无
代码示例：
@Test
public void parallelPrefixTest() {
String[] s1 = {"java", "c++", "html", "css", "Javascript", "world"};
System.out.println(Arrays.toString(s1)); //[java, c++, html, css, Javascript, world]
Arrays.parallelPrefix(s1, String::concat);
System.out.println(Arrays.toString(s1)); //[java, javac++, javac++html, javac++htmlcss, javac++htmlcssJavascript, javac++htmlcssJavascriptworld]
int[] a = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 5]
Arrays.parallelPrefix(a, (x, y) -> x * y);
System.out.println(Arrays.toString(a)); //[1, 2, 6, 24, 120]
Arrays.parallelPrefix(a, 2, 4, (x, y) -> x / y);
System.out.println(Arrays.toString(a)); //[1, 2, 6, 0, 120] 也可指定范围
}
setAll() 和 parallelSetAll()
功能：使用提供的生成器函数设置指定数组的所有元素以计算每个元素。
参数：
- parallelSetAll(T[] array, IntFunction<? extends T> generator)
- setAll(T[] array, IntFunction<? extends T> generator)
返回值：无
代码示例：
@Test
public void setAllTest() {
int[] arr = {111, 222, 333, 444, 555};
Arrays.setAll(arr, (e) -> e + 5);
System.out.println(Arrays.toString(arr)); //[5, 6, 7, 8, 9]
String[] str = {"a", "b", "c"};
Arrays.setAll(str, new IntFunction<>() {
@Override
public String apply(int value) {
return value + "java";
}
});
System.out.println(Arrays.toString(str)); //[0java, 1java, 2java]
int[] arr1 = {111, 222, 333, 444, 555};
Arrays.parallelSetAll(arr1, new IntUnaryOperator() {
@Override
public int applyAsInt(int operand) {
return operand + 5;
}
});
System.out.println(Arrays.toString(arr1)); //[5, 6, 7, 8, 9]
String[] str1 = {"a", "b", "c"};
Arrays.parallelSetAll(str1, (m) -> m + "haha");
System.out.println(Arrays.toString(str1)); //[0haha, 1haha, 2haha]
//总结setAll和parallelSetAll差不多，且都支持lambda
//通过索引值去改变元素，改编后的值与索引有关
}
本文大致包含了所有的方法，除了Java 11之后新增的，或者我看漏的，文中如有错误，还请指出，大家一起进步！
