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]