Arrays 类是一个工具类,其中包含了数组操作的很多方法。这个 Arrays 类里均为 static 修饰的方法(static 修饰的方法可以直接通过类名调用),可以直接通过 Arrays.xxx(xxx) 的形式调用方法。
基础使用函数
1)int binarySearch(type[] a, type key)
使用二分法查询 key 元素值在 a 数组中出现的索引,如果 a 数组不包含 key 元素值,则返回负数。调用该方法时要求数组中元素己经按升序排列,这样才能得到正确结果。
2)int binarySearch(type[] a, int fromIndex, int toIndex, type key)
这个方法与前一个方法类似,但它只搜索 a 数组中 fromIndex 到 toIndex 索引的元素。调用该方法时要求数组中元素己经按升序排列,这样才能得到正确结果。
3)type[] copyOf(type[] original, int length)
这个方法将会把 original 数组复制成一个新数组,其中 length 是新数组的长度。如果 length 小于 original 数组的长度,则新数组就是原数组的前面 length 个元素,如果 length 大于 original 数组的长度,则新数组的前面元索就是原数组的所有元素,后面补充 0(数值类型)、false(布尔类型)或者 null(引用类型)。
4)type[] copyOfRange(type[] original, int from, int to)
这个方法与前面方法相似,但这个方法只复制 original 数组的 from 索引到 to 索引的元素。
5)boolean equals(type[] a, type[] a2)
如果 a 数组和 a2 数组的长度相等,而且 a 数组和 a2 数组的数组元素也一一相同,该方法将返回 true。
6)void fill(type[] a, type val)
该方法将会把 a 数组的所有元素都赋值为 val。
7)void fill(type[] a, int fromIndex, int toIndex, type val)
该方法与前一个方法的作用相同,区别只是该方法仅仅将 a 数组的 fromIndex 到 toIndex 索引的数组元素赋值为 val。
8)void sort(type[] a)
该方法对 a 数组的数组元素进行排序。
9)void sort(type[] a, int fromIndex, int toIndex)
该方法与前一个方法相似,区别是该方法仅仅对 fromIndex 到 toIndex 索引的元素进行排序。
10)String toString(type[] a)
该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起,多个数组元素使用英文逗号,
和空格隔开。
package Work;
import java.util.Arrays;
/**
* a数组和a2数组是否相等:true
* a数组和b数组是否相等:true
* b 数组的元素为:[3, 4, 5, 6]
* b 数组的元素为:[3, 4, 1, 1]
* b数组的元素为:[1, 1, 3, 4]
*/
public class arrays_tools {
public static void main(String[] args) {
// 定义一个a数组
int[] a = new int[] { 3, 4, 5, 6 };
// 定义一个a2数组
int[] a2 = new int[] { 3, 4, 5, 6 };
// a数组和a2数组的长度相等,毎个元素依次相等,将输出true
System.out.println("a数组和a2数组是否相等:" + Arrays.equals(a, a2));
// 通过复制a数组,生成一个新的b数组
int[] b = Arrays.copyOf(a, a2.length);
System.out.println("a数组和b数组是否相等:" + Arrays.equals(a, b));
// 输出b数组的元素,将输出[3, 4, 5, 6, 0, 0]
System.out.println("b 数组的元素为:" + Arrays.toString(b));
// 将b数组的第3个元素(包括)到第5个元素(不包括)賦值为1
Arrays.fill(b, 2, 4, 1);
// 输出b数组的元素,将输出[3, 4, 1, 1, 0, 0]
System.out.println("b 数组的元素为:" + Arrays.toString(b));
// 对b数组进行排序
Arrays.sort(b);
// 输出b数组的元素.将输出[0,0,1,1,3,4]
System.out.println("b数组的元素为:" + Arrays.toString(b));
}
}
更多内容
1)oid parallelPrefix(xxx[] array, XxxBinaryOperator op)
该方法使用 op 参数指定的计算公式计算得到的结果作为新的元素。op 计算公式包括 left、right 两个形参,其中 left 代表数组中前一个索引处的元素,right 代表数组中当前索引处的元素,当计算第一个新数组元素时,left 的值默认为 1。
2)void parallelPrefix(xxx[] array, int fromIndex, int toIndex, XxxBinaryOperator op)
该方法与上一个方法相似,区别是该方法仅重新计算 fromIndex 到 toIndex 索引的元素。
3)void setAll(xxx[] array, IntToXxxFunction generator)
该方法使用指定的生成器(generator)为所有数组元素设置值,该生成器控制数组元素的值的生成算法。
4)void parallelSetAll(xxx[] array, IntToXxxFunction generator)
该方法的功能与上一个方法相同,只是该方法增加了并行能力,可以利用多 CPU 并行来提高性能。
5)void parallelSort(xxx[] a)
该方法的功能与 Arrays 类以前就有的 sort() 方法相似,只是该方法增加了并行能力,可以利用多 CPU 并行来提高性能。
6)void parallelSort(xxx[] a,int fromIndex, int toIndex)
该方法与上一个方法相似,区別是该方法仅对 fromIndex 到 toIndex 索引的元素进行排序。
7)Spliterator.OfXxx spliterator(xxx[] array)
将该数组的所有元素转换成对应的 Spliterator 对象。
8)Spliterator.OfXxx spliterator(xxx[] array, int startInclusive, int endExclusive)
该方法与上一个方法相似,区别是该方法仅转换 startInclusive 到 endExclusive 索引的元素。
9)XxxStream stream(xxx[] array)
该方法将数组转换为 Stream,Stream 是 Java 8 新增的流式编程的 API。
10)XxxStream stream(xxx[] array, int startInclusive, int endExclusive)
该方法与上一个方法相似,区别是该方法仅将 fromIndex 到 toIndex 索引的元索转换为 Stream。
上面方法列表中,所有以 parallel 开头的方法都表示该方法可利用 CPU 并行的能力来提高性能。上面方法中的 xxx 代表不同的数据类型,比如处理 int[] 型数组时应将 xxx 换成 int,处理 long[] 型数组时应将 XXX 换成 long。
package work;
import java.util.Arrays;
import java.util.function.IntBinaryOperator;
import java.util.function.IntUnaryOperator;
public class Text {
public static void main(String[] args) {
int[] array = new int[]{1,2,3,4,56,7};
/*
void parallelSort(xxx[] a)
@param a:array
@return void
void parallelSort(xxx[] a,int fromIndex, int toIndex)
@param a:array
@param fromIndex:int 开始数组下标
@param toIndex 结束数组下标
@return void 排序结果
该方法的功能与 Arrays 类以前就有的 sort() 方法相似,只是该方法增加了并行能力,可以利用多 CPU 并行来提高性能。
*/
Arrays.parallelSort(array);
System.out.println(Arrays.toString(array));
int [] array2= Arrays.copyOf(array,array.length);
Arrays.parallelPrefix(array2, new IntBinaryOperator() {
@Override
/*
原理很简单,其实一句话说就是 用当前元素的值去乘以前一个元素的值,然后再赋值给当前元素
@param left 代表数组中前一个索引处的元素,计算第一个元素时,left为1
@param right 代表数组中当前索引处的元素
@return void
|void parallelPrefix(xxx[] array, int fromIndex, int toIndex, XxxBinaryOperator op)
|该方法与上一个方法相似,区别是该方法仅重新计算 fromIndex 到 toIndex 索引的元素。
*/
public int applyAsInt(int left, int right) {
return left*right;
}
});
System.out.println(Arrays.toString(array2));
int[] arr3=new int[5];
Arrays.parallelSetAll(arr3, new IntUnaryOperator() {
/*
void setAll(xxx[] array, IntToXxxFunction generator)
原理也很简单:及迭代生成数组,去让每一个元素去与前一个元素比较进行生成数组
@param operand代表正在子酸的元素的索引
@param void
|void parallelSetAll(xxx[] array, IntToXxxFunction generator)
|该方法的功能与上一个方法相同,只是该方法增加了并行能力,可以利用多 CPU 并行来提高性能。
*/
@Override
public int applyAsInt(int operand) {
//operand代表正在子酸的元素的索引
return operand*5;
}
});
System.out.println(Arrays.toString(arr3));
}
}
输出结果
[1, 2, 3, 4, 7, 56]
[1, 2, 6, 24, 168, 9408]
[0, 5, 10, 15, 20]