文章目录
前言
在我们的编程生涯中，数组是我们经常会遇到的数据结构。它们用于存储多个值在一个单一的变量下。
在 Java 中，我们有一个特殊的工具类 Arrays，它提供了一些非常实用的方法，可以帮助我们在处理数组时更加高效和便捷。
在这篇文章中，我们将详细介绍 Arrays 工具类的使用。
Aarry的几个常用函数：
-
排序 :
sort() -
查找 :
binarySearch() -
比较:
equals() -
填充 :
fill() -
转列表:
asList() -
转字符串 :
toString() -
复制:
copyOf()排序 : sort()
1 void sort(Object[] o)：对数组从小到大的排序(String类型的数组不宜使用)
2.void sort(int[] a, int fromIndex, int toIndex)：对数组(from,to)从小到大的排序(String类型的数组不宜使用)
只排(fromIndex,toIndex)之间的数值，且不包括fromIndex和toIndex。
3.void sort(T[] a, Comparator<? super T> c)：类似Collections工具类的sort
4.void parallelSort(int[] a) 按照数字顺序排列指定的数组(并行的)。同sort方法一样也有按范围的排序
int a[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
// void sort(Object[] o)：对数组从小到大的排序
Arrays.sort(a);
System.out.println("Arrays.sort(a):");
for (int i : a) {
System.out.print(i);
}
// 换行
System.out.println();
String[] strs = { "abc", "abd", "abf" };
Arrays.sort(strs);
System.out.println("Arrays.toString(strs)");
for (String str : strs) {
System.out.print(str);
}
// 换行
System.out.println();
// void sort(int[] a, int fromIndex, int toIndex)：对数组(from,to)从小到大的排序
//只排(fromIndex,toIndex)之间的数值，且不包括fromIndex和toIndex。
int b[] = a.clone();
Arrays.sort(b, 2, 6);
System.out.println("Arrays.sort(b, 2, 6):");
for (int i : b) {
System.out.print(i);
}
// 换行
System.out.println();
// void sort(T[] a, Comparator<? super T> c)：类似Collections工具类的sort
Integer[] c=new Integer[]{1, 3, 2, 7, 6, 5, 4, 9};
Arrays.sort(c,new Comparator<Integer>()
{
public int compare(Integer o1, Integer o2)
{
return o2-o1;
}
public boolean equals(Object obj)
{
return false;
}
});
System.out.println("Arrays.sort(b, new Comparator<Integer>):");
for (Integer integer:c)
{
System.out.print(integer);
}
// 换行
System.out.println();
// parallelSort(int[] a) 按照数字顺序排列指定的数组(并行的)。同sort方法一样也有按范围的排序
int d[] = a.clone();
Arrays.parallelSort(d);
System.out.println("Arrays.parallelSort(d)：");
for (int i : d) {
System.out.print(i);
}
// 换行
System.out.println();
//parallelSort给字符数组排序，sort也可以
char e[] = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
Arrays.parallelSort(d);
System.out.println("Arrays.parallelSort(e)：");
for (char ch : e) {
System.out.print(ch);
}
// 换行
System.out.println();
输出结果：
Arrays.sort(a):
12345679
Arrays.toString(strs)
abcabdabf
Arrays.sort(b, 2, 6):
12345679
Arrays.sort(b, new Comparator<Integer>):
97654321
Arrays.parallelSort(d)：
12345679
Arrays.parallelSort(e)：
afbceACB
查找 : binarySearch()
1.int binarySearch(Object[] a, Object key)：在a数组中查找key,返回key在数组中的位置
二分查找法找指定元素的索引值，数组一定是排好序的，否则会出错。找到元素，只会返回最后一个位置 。
2.int binarySearch(int[] a, int fromIndex, int toIndex, int key)：在a数组中查找key,返回key在数组中的位置[fromIndex,toIndex)(不包括toIndex)
int arr[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
//int binarySearch(Object[] a, Object key)：在a数组中查找key,返回key在数组中的位置 (无序)
int a1=Arrays.binarySearch(arr,10);
int a2=Arrays.binarySearch(arr,6);
System.out.println("not sort arr:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+",");
}
System.out.println();
System.out.println("search a1, a2:");
System.out.print("a1:"+a1+",a2:"+a2);
// 换行
System.out.println();
Arrays.sort(arr);
//int binarySearch(Object[] a, Object key)：在a数组中查找key,返回key在数组中的位置 (有序)
a1=Arrays.binarySearch(arr,10);
a2=Arrays.binarySearch(arr,6);
System.out.println("sort arr:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+",");
}
System.out.println();
System.out.println("search a1, a2:");
System.out.print("a1:"+a1+",a2:"+a2);
System.out.println();
//int binarySearch(int[] a, int fromIndex, int toIndex, int key)：在a数组中查找key,返回key在数组中的位置[fromIndex,toIndex)
a1=Arrays.binarySearch(arr,0,4,6);
a2=Arrays.binarySearch(arr,0,6,6);
System.out.println("search index a1, a2:");
System.out.print("a1:"+a1+",a2:"+a2);
System.out.println();
输出结果：
not sort arr:
1,3,2,7,6,5,4,9,
search a1, a2:
a1:-9,a2:-4
sort arr:
1,2,3,4,5,6,7,9,
search a1, a2:
a1:-9,a2:5
search index a1, a2:
a1:-5,a2:5
比较: equals()
boolean equals(Object[] a, Object[] a2)：比较两个数据是否相等，如果两个数组引用都是null，则它们被认为是相等的
//boolean equals(Object[] a, Object[] a2)：比较两个数据是否相等
String string1[]={"1","2","3","4","5"};
String string2[]={"1","3","5","7","9"};
String string3[]={"1","3","5","7","9"};
String string4[]=null;
String string5[]=null;
boolean b1= Arrays.equals(string1,string2);
boolean b2=Arrays.equals(string2,string3);
boolean b3=string2.equals(string3);
boolean b4=Arrays.equals(string1,string3);
boolean b5=Arrays.equals(string4,string5);
System.out.println("b1:"+b1+",b2:"+b2+",b3:"+b3+",b4:"+b4+",b5:"+b5);
输出结果：
b1:false,b2:true,b3:false,b4:false,b5:true
填充 : fill()
1. void fill(Object[] a, Object val)：填充数组
2. void fill(Object[] a, int fromIndex, int toIndex, Object val)：填充数组[fromIndex,toIndex)
int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// 数组中所有元素重新分配值
Arrays.fill(a, 3);
System.out.println("Arrays.fill(a, 3)：");
for (int i : a) {
System.out.print(i);
}
// 换行
System.out.println();
int[] b = a.clone();
// 数组中指定范围元素重新分配值
Arrays.fill(b, 0, 2, 9);
System.out.println("Arrays.fill(b, 0, 2, 9):");
for (int i : b) {
System.out.print(i);
}
输出结果：
Arrays.fill(a, 3)：
333333333
Arrays.fill(b, 0, 2, 9):
993333333
转列表 asList()
List<T> asList(T... a)：将数组转换成集合
int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// 数组中所有元素重新分配值
System.out.println("int[] a：");
for(int i:a){
System.out.print(i);
}
System.out.println();
List<int[]> list=Arrays.asList(a);
Iterator<int[]> iterator=list.iterator();
System.out.println("List<int[]> list：");
while (iterator.hasNext()){
int []result=iterator.next();
for(int i:result){
System.out.print(i);
}
}
输出结果：
int[] a：
123456789
List<int[]> list：
123456789
转字符串 toString()
返回指定数组的内容的字符串表示形式
int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
System.out.println("Arrays.toString(a)：");
System.out.println(Arrays.toString(a));
输出结果：
Arrays.toString(a)：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
复制 copyOf()
1.int[] copyOf(int[] original, int newLength)：从original数组中截取长度为newLength的新数组
2.int[] copyOfRange(int[] original, int from, int to)：从original数组中截取[from,to)新数组
int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//copyOf 方法实现数组复制,a为数组，6为复制的长度
int a1[] = Arrays.copyOf(a, 6);
System.out.println("Arrays.copyOf(a, 6)：");
for (int i : a1) {
System.out.print(i);
}
// 换行
System.out.println();
// copyOfRange将指定数组的指定范围复制到新数组中
int a2[] = Arrays.copyOfRange(a, 4, 8);
System.out.println("Arrays.copyOfRange(a, 4, 8)：");
for (int j : a2) {
System.out.print(j);
}
// 换行
System.out.println();
输出结果:
Arrays.copyOf(a, 6)：
123456
Arrays.copyOfRange(a, 4, 8)：
5678
应用场景
数组排序：
Arrays 类提供了 sort() 方法，可以快速对数组进行排序。
java复制代码int[] arr = {10, 20, 15, 22, 35};
Arrays.sort(arr);
数组搜索：
使用 Arrays 类的 binarySearch() 方法，可以在排序好的数组中快速查找元素。
java复制代码int intKey = 22;
int foundIndex = Arrays.binarySearch(arr, intKey);
数组比较：
Arrays 类的 equals() 方法可以用来检查两个数组是否相等（即所有相应的元素是否相等）。
java复制代码int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = {1, 2, 3, 4, 5};
boolean isEqual = Arrays.equals(arr1, arr2);
数组填充：
Arrays 类的 fill() 方法可以用来将所有元素设置为指定的值。
java复制代码int[] arr = new int[5];
Arrays.fill(arr, 10);
数组转列表：
Arrays 类的 asList() 方法可以将数组转换为列表。
java复制代码String[] arr = {"a", "b", "c"};
List<String> list = Arrays.asList(arr);
优缺点
优点
易用性：
Arrays 类提供了一系列静态方法，可以方便地操作数组，如排序、查找、比较等，使得数组的操作更加简洁易用。
效率：
Arrays 类的很多方法，如排序和二分查找，都使用了高效的算法，能够提供良好的性能。
兼容性：
Arrays 类的方法可以用于任何类型的数组，不仅限于原始类型，还包括对象类型，这使得它具有很好的兼容性。
缺点
不支持动态扩容：
Arrays 工具类并不能改变 Java 数组的固有特性——大小固定。如果需要动态扩容，我们需要使用其他数据结构，如 ArrayList。
无法处理多维数组：
虽然 Arrays 类可以处理一维数组，但是对于多维数组，它的方法可能就无法直接使用了。
有些方法只适用于已排序的数组：
如 binarySearch() 方法，如果在未排序的数组上使用，可能得不到正确的结果。
总的来说，Arrays 类是一个非常实用的工具类，它在简化数组操作和提高效率方面做出了很大的贡献。但是，由于其自身的一些限制，我们在使用时还需要结合其他工具和数据结构。
总结
以上就是 Arrays 工具类的详细介绍。
通过这篇文章，我们可以看到 Arrays 类提供了许多实用的方法来帮助我们处理数组。
无论是排序，搜索，还是转换为列表，Arrays 类都能让我们的工作变得更加轻松。
希望这篇文章能帮助到你，让你在处理数组时，能更加得心应手。
写在最后
感谢您的支持和鼓励！ 😊🙏
如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot, spring cloud等系列文章，一系列干货随时送达!
扫一扫
474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
