一、概述

  在 Java 的util包中提供了一个Arrays工具类用来操作数组的，它提供了许多的静态方法，主要包含了操纵数组的各种方法，例如数组所有元素进行排序，按从小到大的顺序、查找元素等。使用时导包import java.util.Arrays，并使用Arrays.方法（）进行调用方法。

二、常用方法

方法	说明
asList	将数组转换为一个固定的List链表对象
binarySearch	在数组中查找元素。 若找到，则返回此值的下标，若没找到，返回 -1；
copyOf	拷贝数组。 第一个参数是原数组，第二个参数是拷贝长度，返回值是将原数组拷贝一份返回
copyOfRange
deepEquals
deepHashCode
deepToString(Object[][] arrays)	返回多维数组的字符串形式
equals	比较两个数组内容是否相等。
fill(Object[] array,Object object)	为数组元素填充相同的值
fill(Object[] array,int from,int to,Object object)	对数组的部分元素填充一个值，从起始位置到结束位置，取头不取尾
parallelPrefix
parallelSetAll
parallelSort
setAll
sort() sort(Object[] array)	对数组元素指定范围进行排序，默认升序。 对字符串进行排序时，是对每一个字符比较，而不是简单的比较长度
sort(Object[] array, int from, int to)	对数组元素指定范围进行排序（排序范围是从元素下标为from,到下标为to-1的元素进行排序）
spliterator
stream

三、简单使用

3.1 Arrays的sort排序

  在以前学数组的时候，要对数组进行排序就需要定义一个排序的方法，就比较麻烦，在Arrays工具类的静态方法中提供了 sort 方法，主要是对基本类型的数组所有元素进行排序，按从小到大的顺序。在可以对原数组元素顺序进行改变时，可以使用这些现成的排序工具方法，如下所示。

// 对int型数组进行排序，会改变原数组中的元素位置
public static void sort(int[] a){...}
// 对数组fromIndex下标(包含)到toIndex下标(不包含)的元素进行排序，同样会改变原数组的元素
public static void sort(int[] a, int fromIndex, int toIndex){...}
// long型数组的排序
public static void sort(long[] a){...}
public static void sort(long[] a, int fromIndex, int toIndex){...}
// short型数组的排序
public static void sort(short[] a){...}
public static void sort(short[] a, int fromIndex, int toIndex){...}
// char型数组的排序
public static void sort(char[] a){...}
public static void sort(char[] a, int fromIndex, int toIndex){...}
// byte型数组的排序
public static void sort(byte[] a){...}
public static void sort(byte[] a, int fromIndex, int toIndex){...}
// float型数组的排序
public static void sort(float[] a){...}
public static void sort(float[] a, int fromIndex, int toIndex){...}
// double型数组的排序
public static void sort(double[] a){...}
public static void sort(double[] a, int fromIndex, int toIndex){...}

示例如下所示：

@Test
public void test() {
    int arr[] = {10, 7, 9, 2, 6, 1};
    System.out.println("数组排序前元素有：");
    for (int a : arr) {
        System.out.print(a + "\t");
    }
    System.out.println("\n数组排序后元素有：");
    Arrays.sort(arr);
    for (int a : arr) {
        System.out.print(a + "\t");
    }
}

运行的结果如下所示：

数组排序前元素有：
10	7	9	2	6	1	
数组排序后元素有：
1	2	6	7	9	10	

从上面代码中，不需要定义一个排序的方法，直接使用Arrays工具类中sort静态方法减少了代码的书写量，方法操作。

3.2 Arrays的binarySearch查找

  在程序开发中，经常会使用数组查找需要的元素，如果数组的元素比较多查找某一个元素就比较麻烦，在Arrsys工具类提供了静态的binarySearch方法，它的作用是通过二分法在已经排好序的数组中查找指定的元素，并返回该元素的下标，找不到指定元素时返回下标值小于0，如下所示。

// int排序数组中的二分查找
public static int binarySearch(int[] a, int key){...}
// 对int数组fromIndex下标数组fromIndex下标(包含)到toIndex下标(不包含)的元素的二分查找
public static int binarySearch(int[] a, int fromIndex, int toIndex, int key){...}
// short排序数组中的二分查找
public static int binarySearch(short[] a, short key){...}
public static int binarySearch(short[] a, int fromIndex, int toIndex, short key){...}
// char排序数组中的二分查找
public static int binarySearch(char[] a, char key){...}
public static int binarySearch(char[] a, int fromIndex, int toIndex, char key){...}
// byte排序数组中的二分查找
public static int binarySearch(byte[] a, byte key){...}
public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key){...}
// double排序数组中的二分查找
public static int binarySearch(double[] a, double key){...}
public static int binarySearch(double[] a, int fromIndex, int toIndex, double key){...}
// float排序数组中的二分查找
public static int binarySearch(float[] a, float key){...}
public static int binarySearch(float[] a, int fromIndex, int toIndex, float key){...}

示例如下所示：

@Test
public void test() {
    int arr[] = {10, 7, 9, 2, 6, 1};
    // 数组排序方法
    Arrays.sort(arr);
    System.out.println("数组排序后元素有：");
    // 使用foreach循环遍历数组的所有元素
    for (int a : arr) {
        System.out.print(a + "\t");
    }
    // 查找指定元素6，返回它的索引值
    int index = Arrays.binarySearch(arr, 6);
    System.out.println("\n数组排序后元素6的索引值是：" + index);
}

运行的结果如下所示：

数组排序后元素有：
1	2	6	7	9	10	
数组排序后元素6的索引值是：2

3.3 Arrays的fill填充

  在程序开发中，经常会使用数组若给数组填充值时，在Arrays数组中提供了 fill 方法是对数组部分的元素填充一个值，从开始位置到结束位置，取左边不取右边。
  在初始化一个数组之后，如果没有给数组的元素赋值，那么这个数组中的元素默认是为0的，那么我们一个个进行赋值又会略显麻烦，会堆积代码！所以我们就需要用到fill方法进行填充，但是这么做会让全部元素变成同一个数值！

@Test
public void test() {
    //这里创建一个名称为 myList 的数组，数组的元素个个数为5
    int[] myList = new int[5];
    //为数组填充3，格式为fill(列表,数值)
    Arrays.fill(myList, 3);
    for (int x : myList) {
        System.out.print(x + "\t");
    }
}

运行的结果如下所示：

3	3	3	3	3

  在给元素赋值完或者是填充完元素之后，如果想对某个元素进行修改，那么我们就要重新赋值或者是替换元素，但是重新赋值会增加代码，让代码显得更繁琐，所以Arrays类中提供了替换元素的方法fill！

@Test
public void test() {
    int arr[] = {10, 7, 9, 2, 6, 1};
    System.out.println("数组元素有：");
    for (int a : arr) {
        System.out.print(a + "\t");
    }
    // 给数组下标的1到4元素的赋值为5
    Arrays.fill(arr, 1, 4, 5);
    System.out.println("\n数组元素有：");
    for (int a : arr) {
        System.out.print(a + "\t");
    }
}

运行的结果如下图所示：

数组元素有：
10	7	9	2	6	1	
数组元素有：
10	5	5	5	6	1

3.4 Arrays的copyOf复制数组

  在Java程序的使用过程中，有时候会需要一个含有相同或者是部分相同元素的数组，但是重新创建数组的话就会增加代码长度，减少代码可读性，那么我们就可以使用到复制数组或者是部分数组的方法！copyOf方法提供了多种重载的方法，用以复制数组，增加代码可读性。该方法不受数组长度的限制，若超出，则多处部分为0！

public static boolean[] copyOf(boolean[] original, int newLength);
public static byte[] copyOf(byte[] original, int newLength);
public static char[] copyOf(char[] original, int newLength);
public static double[] copyOf(double[] original, int newLength);
public static float[] copyOf(float[] original, int newLength);
public static int[] copyOf(int[] original, int newLength);
public static long[] copyOf(long[] original, int newLength);
public static short[] copyOf(short[] original, int newLength);
public static <T> T[] copyOf(T[] original, int newLength);

示例如下所示：

@Test
public void test() {
    int[] myList = {1, 2, 3, 4};
    int[] justList = Arrays.copyOf(myList, 4);
    for (int x : justList) {
        System.out.println(x);
    }
    System.out.println(myList);
    System.out.println(justList);
}

运行的结果如下图所示：

1
2
3
4
[I@45fe3ee3
[I@4cdf35a9

从以上结果可以看出赋值成功了，并且内存空间不同

3.5 Arrays的copyOfRange复制部分

  有时候在编辑代码的时候只需要中间一部分代码，但是copyOf方法只能复制以前面部分为开头的元素，而不能直接复制中间的代码，为了解决这一个问题，这个类提供了另一个方法copyOfRange方法（中文意思：选择复制）利用这个方法就可以解决这一个问题！

public static boolean[] copyOf(boolean[] original, int newLength);
public static byte[] copyOf(byte[] original, int newLength);
public static char[] copyOf(char[] original, int newLength);
public static double[] copyOf(double[] original, int newLength);
public static float[] copyOf(float[] original, int newLength);
public static int[] copyOf(int[] original, int newLength);
public static long[] copyOf(long[] original, int newLength);
public static short[] copyOf(short[] original, int newLength);
public static <T> T[] copyOf(T[] original, int newLength);

示例如下所示：

@Test
public void test() {
    int[] myList = {1, 2, 3, 4};
    int[] justList = Arrays.copyOfRange(myList, 1, 3);
    // Arrays类的方法使用形式Arrays.copyOfRange(列表,第一个索引位置,第二个索引位置)
    for (int x : justList) {
        System.out.println(x);
    }
}

运行的结果如下图所示：

2
3

Arrays的asList数组转链表

  将数组转换成链表形式返回，返回的是内部类ArrayList。对于这个链表，更改操作只有set，而且会改变原来的数组内容；另外就是不支持add操作，对于add调用，会抛出 UnsupportedOperationException 异常(没有重写add实现时的默认实现)。

 public static <T> List<T> asList(T... a){...}

四、总结

  本文主要介绍了Arrays工具类的导包，举了一些常用方法示例。这些方法通过案例实现帮助理解，希望大家通过本文的学习，对你有所帮助！