java中Arrays工具类的用法

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

• 给数组赋值：通过fill方法。
• 对数组排序：通过sort方法,按升序
• 比 较 数 组： 通过equals方法比较数组中元素值是否相等。
• 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
• 截取数组元素：通过copyOf方法和copyOfRange对数组元素进行截取。
• 打印数组元素：通过toString方法打印数组元素。
• 将数组转换为list：通过asList方法转换为List。

在此先创建一个打印数组的方法，方便后面直接使用

public static void output(int[] list){
        for(int i = 0;i < list.length;i++){
            System.out.print(list[i]+" ");
        }
        System.out.println();
    }

1、填充数组：fill

eg1

int[] array=new int[5]; 
Arrays.fill(array,5);
System.out.println("填充数组：Arrays.fill(array, 5)：");
output(array);

结果是：5 5 5 5 5
分析：给所有值赋值5
eg2

int[] array=new int[5]; 
Arrays.fill(array, 2, 4, 8);
output(array);

结果是：5 5 8 8 5
分析：给第2位（0开始）到第4位（不包括）赋值8

2、数组元素排序：sort

eg1

int[] intTest={15,78,32,5,29,22,17,34};
Arrays.sort(intTest);
output(intTest);

结果是：5 15 17 22 29 32 34 78
分析：给所有数按升序排序
eg2

int[] intTest={15,78,32,5,29,22,17,34};
Arrays.sort(intTest,2,6);
output(intTest);

结果是：15 78 5 22 29 32 17 34
分析：给第2位（0开始）到第6位（不包括）排序

3、比较数组元素是否相等：equals

int []arr1 = {1,2,3};
int []arr2 = {1,2,3};
System.out.println(Arrays.equals(arr1,arr2));

结果是：true
分析：如果是arr1.equals(arr2),则返回false，因为equals比较的是两个对象的地址，不是里面的数，而Arrays.equals重写了equals，所以，这里能比较元素是否相等。
注意：如果两个数组元素值一样，但是两个数组对应位置元素不同，Arrays.equals返回结果是false。

int[] intTesta={15,78,32,5,29,22,17,34};
int[] intTestb={78,15,32,5,29,22,17,34};
System.out.println(Arrays.equals(intTesta, intTestb));

结果是：false
分析：两个数组对应位置的元素不相等。

4、二分查找法找指定元素的索引值（下标）：binarySearch

注意：数组一定是排好序的，否则会出错。找到元素，只会返回最后一个位置
eg1

int[] testA={5,7,12,45,57,66,81};
System.out.println(Arrays.binarySearch(testA, 12));

结果是：2
分析：能找到该元素，返回下标为2（0开始）
eg2

int[] testA={5,7,12,45,57,66,81};
System.out.println(Arrays.binarySearch(testA, 9));

结果是：-3
分析：找不到元素，返回-x，从-1开始数，如题，返回-3
eg3

int[] testA={5,7,12,45,57,66,81};
System.out.println(Arrays.binarySearch(testA, 0,3,12));

结果是：2
分析：从0到3位（不包括）找12，找到了，在第2位，返回2
eg4

int[] testA={5,7,12,45,57,66,81};
System.out.println(Arrays.binarySearch(testA, 0,2,12));

结果是：-3
分析：从0到2位（不包括）找12，找不到，从-1开始数，返回-3

5、截取数组：copeOf和copeOfRange

eg1 copyOf

int[] array={5, 5, 8, 8, 5};
int[] copyarray = Arrays.copyOf(array, 4);
output(copyarray);

结果是：5 5 8 8
分析：截取array数组的4个元素赋值给数组copyarray
eg2 copyOfRange

int[] array={5, 5, 8, 8, 5};
int[] copyOfRange = Arrays.copyOfRange(array, 1, 4);
output(copyOfRange);

结果是：5 8 8
分析：从第1位（0开始）截取到第4位（不包括）

6、打印数组元素：toString

直接toString方法打印数组元素

String[] stringTest = {"hello","how","are","you","!"};
System.out.println(Arrays.toString(stringTest));

结果：[hello, how, are, you, !]

7、数组转换List：asList

将数组转换为List

String[] stringTest = {"hello","how","are","you","!"};
List<String> list = Arrays.asList(stringTest);
for(String te : list){
    System.out.print(te+" ");
}

结果：hello how are you !

java示例代码

import java.util.Arrays;
import java.util.List;

public class ArrayClassTest {

    /**
     * 打印数组元素
     * @param list
     */
    public static void output(int[] list){
        for(int i = 0;i < list.length;i++){
            System.out.print(list[i]+" ");
        }
        System.out.println();
    }

    public static void main(String[] args) {

        int[] intTest={15,78,32,5,29,22,17,34};
        int[] array=new int[5];

        //填充数组
        Arrays.fill(array,5);
        System.out.println("填充数组：Arrays.fill(array, 5)：");
        output(array);

        //将数组的第2和第3个元素赋值为8
        Arrays.fill(array, 2, 4, 8);
        System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
        output(array);

        //对数组的第2个到第5个进行排序进行排序
        Arrays.sort(intTest,2,6);
        System.out.println("对数组的第2个到第5个元素进行排序进行排序：Arrays.sort(intTest,2,6)：");
        output(intTest);

        //对整个数组进行排序
        Arrays.sort(intTest);
        System.out.println("对整个数组进行排序：Arrays.sort(intTest)：");
        output(intTest);

        //比较数组元素是否相等
        System.out.println("比较数组元素是否相等:Arrays.equals(array, intTest):"+"\n"+Arrays.equals(array, intTest));
        int[] array1 = array.clone();
        System.out.println("克隆后数组元素是否相等:Arrays.equals(array, array1):"+"\n"+Arrays.equals(array, array1));

        //注意：数组对应位置元素相等Arrays.equals结果才为true
        int[] intTesta={15,78,32,5,29,22,17,34};
        int[] intTestb={78,15,32,5,29,22,17,34};
        System.out.println("数组前两个元素位置颠倒结果是否相等:Arrays.equals(intTesta, intTestb):"+"\n"+Arrays.equals(intTesta, intTestb));

        //使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
        int[] testA={5,7,12,45,57,66,81};
        System.out.println("元素12在testA中的位置：Arrays.binarySearch(testA, 12)："+"\n"+Arrays.binarySearch(testA, 12));

        //如果不存在就返回负数
        System.out.println("元素9在testA中的位置：Arrays.binarySearch(testA, 9)："+"\n"+Arrays.binarySearch(testA, 9));

        //从指定位置中查找元素
        System.out.println("元素12在testA中0到3的位置：Arrays.binarySearch(testA, 0,3,12)："+"\n"+Arrays.binarySearch(testA, 0,3,12));

        //从指定位置中查找元素，元素不存在
        System.out.println("元素12在testA中0到2的位置：Arrays.binarySearch(testA, 0,2,12)："+"\n"+Arrays.binarySearch(testA, 0,2,12));

        //截取数组
        int[] copyarray = Arrays.copyOf(array, 4);
        System.out.println("copyOf方法截取的数组元素为：");
        output(copyarray);
        int[] copyOfRange = Arrays.copyOfRange(array, 1, 4);
        System.out.println("copyOfRange方法截取的数组元素为：");
        output(copyOfRange);

        //toString方法打印数组元素
        String[] stringTest = {"hello","how","are","you","!"};
        System.out.println("toString方法打印数组元素：");
        System.out.println(Arrays.toString(stringTest));

        //asList方法将数组转换成List
        List<String> list = Arrays.asList(stringTest);
        System.out.println("数组转换为list，打印结果为:");
        for(String te : list){
            System.out.print(te+" ");
        }
    }

}

程序运行结果如下：

填充数组：Arrays.fill(array, 5)：
5 5 5 5 5 
将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：
5 5 8 8 5 
对数组的第2个到第5个元素进行排序进行排序：Arrays.sort(intTest,2,6)：
15 78 5 22 29 32 17 34 
对整个数组进行排序：Arrays.sort(intTest)：
5 15 17 22 29 32 34 78 
比较数组元素是否相等:Arrays.equals(array, intTest):
false
克隆后数组元素是否相等:Arrays.equals(array, array1):
true
数组前两个元素位置颠倒结果是否相等:Arrays.equals(intTesta, intTestb):
false
元素12在testA中的位置：Arrays.binarySearch(testA, 12)：
2
元素9在testA中的位置：Arrays.binarySearch(testA, 9)：
-3
元素12在testA中0到3的位置：Arrays.binarySearch(testA, 0,3,12)：
2
元素12在testA中0到2的位置：Arrays.binarySearch(testA, 0,2,12)：
-3
[5, 5, 8, 8, 5]
copyOf方法截取的数组元素为：
5 5 8 8 
copyOfRange方法截取的数组元素为：
5 8 8 
toString方法打印数组元素：
[hello, how, are, you, !]
数组转换为list，打印结果为:
hello how are you !