Java基础（九）数组工具类

数组工具类

---

1. Arrays类

a. 导入方法

import java.util.Arrays;

b. Arrays类常用的方法

方法	返回类型	说明
equals(array1, array2)	boolean	比较两个数组是否相等
sort(array)	void	对数组 array 的元素进行排序
toString(array)	String	把一个数组 array 转换成一个字符串
fill(array, val)	void	把数组 array 的所有元素都赋值为 val
copyOf(array, length)	与 array 数据类型一致	把数组 array 复制成一个长度为 length 的新数组
binarySearch(array, val)	int	查询元素值 val 在数组 array 中的下标
compare(array1, array2)	int	按照字典顺序比较数组，前面的数组大，返回大于 0 的值，反之返回小于 0 的值
copyOfRange(arr, start, end)	与 array 数组类型一致	将指定数组的指定范围复制到新数组中
fill(arr, strats, end, val)	void	将指定值分配给指定数组的指定范围的每个元素
mismatch(array1, arrays2)	int	查找并返回两个数组之间第一个不匹配的索引，否则如果未找到不匹配，则返回 -1

2. Arrays类的应用

（1）比较两个数组是否相等

Arrays 类的 equals() 方法用于比较两个数组是否相等。只有当两个数组长度相等，对应位置也一一相等时，该方法返回 true ，否则返回 false。

import java.util.Arrays;

public class Example19 {
    public static void main(String[] args) {
        // 比较两个数组是否相等
        int[] arr1 = {10, 20, 30};
        int[] arr2 = {10, 20, 30};
        int[] arr3 = {10, 20, 30};
        System.out.println(Arrays.equals(arr1,arr2));
        System.out.println(Arrays.equals(arr1,arr3));
        System.out.println(arr1.equals(arr2));
        System.out.println(arr1 == arr2);
    }
}
// true false false false

在这段代码中，Arrays.equals(arr1, arr2) 是调用 Arrays 类的静态方法来比较两个数组的内容是否相等。它会逐个比较两个数组对应位置的元素值是否相等，如果所有元素都相等，则返回 true。

arr1.equals(arr2) 是调用数组对象的 equals 方法来比较两个数组是否是同一个对象。由于数组是对象，使用 equals 方法默认会比较两个数组的引用地址是否相等。在这个例子中，arr1 和 arr2 是不同的数组对象，即使它们的内容相同，它们的引用地址不同，因此 arr1.equals(arr2) 返回的结果是 false。

arr1 == arr2 是直接比较两个数组的引用地址是否相等。同样地，arr1 和 arr2 是不同的数组对象，因此它们的引用地址也不相等，所以 arr1 == arr2 的结果是 false。

综上所述，Arrays.equals(arr1, arr2) 可以比较两个数组的内容是否相等，而 arr1.equals(arr2) 和 arr1 == arr2 比较的是数组对象的引用地址。因此，三者的结果不一样。

（2）对数组元素进行升序排序

Arrays 类的 sort() 对数组的元素进行升序排序。

import java.util.Arrays;
import java.util.Collections;

public class Sort {
    public static void main(String[] args) {
        Integer[] arr = {5, 2, 8, 1, 9};

        // 升序排序
        Arrays.sort(arr);
        System.out.println("升序排序：" + Arrays.toString(arr));

        //降序排序
        Collections.reverse(Arrays.asList(arr));
        System.out.println("降序排序：" + Arrays.toString(arr));
    }
}
/*
升序排序：[1, 2, 5, 8, 9]
降序排序：[9, 8, 5, 2, 1]
*/

• Arrays.aList() 是一个用于将数组转换为列表的方法。它接收一个数组作为参数，并返回一个固定大小的列表，该列表由给定的数组支持。
• 需要注意的是，Arrays.asList() 返回的列表是一个固定大小的列表，意味着不能改变其大小（添加或删除元素），否则会抛出 UnsupportedOperationException 异常。因为底层仍然是原始数组，所以在使用该列表时，对数组的修改会直接反映到列表中，反之亦然。
• Collections.reverse() 是一个用于反转列表元素顺序的方法。它接收一个列表作为参数，并修改该列表，使得列表中的元素按照相反的顺序排列。

（3）将数组元素赋值为相同的值

Arrays 类的 fill() 方法用于把数组 array 的一些或全部元素赋值为 val 。

import java.util.Arrays;

public class FillExample {
    public static void main(String[] args) {
        int[] arr1 = {10, 10, 10, 10, 10};
        int[] arr2 = {10, 10, 10, 10, 10};

        // 全部赋值
        Arrays.fill(arr1, 50);
        System.out.println("arr1为" + Arrays.toString(arr1));
        // 部分赋值
        Arrays.fill(arr2, 1, 3, 30);
        System.out.println("arr2为" + Arrays.toString(arr2));
    }
}
/*
arr1为[50, 50, 50, 50, 50]
arr2为[10, 30, 30, 10, 10]
*/

• 全部赋值
  • Arrays.fill(arr, val) 中，arr 为要赋值的数组，val 需要赋值的值。
• 部分赋值
  • Arrays.fill(arr, fromIndex, toIndex, val) 中，arr 为要赋值的数组，val 需要赋值的值，fromIndex 为开始赋值的数组下标，toIndex 为结束赋值的数组下标（不包含该下标的值）。

（4）将数组赋值成一个长度为设定值的新数组，新数组内容复制

初始化一个整型一维数组，使用 Arrays 类的 copyOf() 方法把数组复制成一个长度为设定值的新数组。
初始化一个整型一维数组，使用 System 类的 arraycopy() 方法把数组复制成一个长度为设定值的新数组。

import java.util.Arrays;

public class CopyOfExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3 ,5, 7};
        // Arrays.copyOf() 复制数组
        // 复制新数组 newLength > arr.length
        int[] arr1 = Arrays.copyOf(arr,7);
        System.out.println("copyOf() arr1 = " + Arrays.toString(arr1));
        // 复制新数组 newLength = arr.length
        int[] arr2 = Arrays.copyOf(arr,5);
        System.out.println("copyOf() arr2 = " + Arrays.toString(arr2));
        // 复制新数组 newLength < arr.length
        int[] arr3 = Arrays.copyOf(arr,3);
        System.out.println("copyOf() arr3 = " + Arrays.toString(arr3));

        // System.arraycopy() 赋值
        int[] arr4 = new int[arr.length + 1];
        System.arraycopy(arr, 0, arr4, 0, 2);
        System.arraycopy(arr, 2, arr4, 3, 3);
        arr4[2] = 6;
        System.out.println("arraycopy() arr4 = " + Arrays.toString(arr4));

    }
}

/* 输出
copyOf() arr1 = [1, 2, 3, 5, 7, 0, 0]
copyOf() arr2 = [1, 2, 3, 5, 7]
copyOf() arr3 = [1, 2, 3]
arraycopy() arr4 = [1, 2, 6, 3, 5, 7]
*/

• Arrays.copyOf()
  • Arrays.copyOf(arr, newLength) 中，arr 为要复制的数组，newLength 为新建数组的长度。
  • 复制新数组 newLength > arr.length，用该数组类型的默认值填充。
  • 复制新数组 newLength = arr.length，新数组和原数组一样。
  • 复制新数组 newLength < arr.length，新数组赋值原数组的前 newLength 位。
• System.arraycopy()
  • System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
  • src: 源数组，被复制的数组。
  • srcPos： 源数组的起始位置，从这一位开始复制。
  • dest： 目标数组。
  • destPos： 目标数组的位置。
  • length： 复制多少元素, 不能比 src.length 大。

（5）查询元素在数组中的下标

Arrays 类的 binarySearch(Object[], Object key) 方法用于查询数组元素在数组中的下标。调用该方法时要求数组中的元素已经按照升序排列。

import java.util.Arrays;

public class Learn1002 {
    public static void main(String[] args) {
        // binarySearch()函数
        int[] arr = {10, 50, 30, 40, 20};
        Arrays.sort(arr);
        System.out.println("arr = " + Arrays.toString(arr));
        // 查找元素在数组内
        int index = Arrays.binarySearch(arr,40);
        System.out.println("index = " + index);
        // 查找元素小于数组中最小值
        index = Arrays.binarySearch(arr, 0);
        System.out.println("index = " + index);
        // 查找元素在数组最小到最大值之间，但不在数组内
        index = Arrays.binarySearch(arr, 45);
        System.out.println("index = " + index);
        // 查找元素大于数组中最大值
        index = Arrays.binarySearch(arr, 60);
        System.out.println("index = " + index);
    }
}

/* 
输出：
arr = [10, 20, 30, 40, 50]
index = 3
index = -1
index = -5
index = -6
*/

如果 key 在数组中，则返回搜索值的索引；如果 key 不在数组中，返回值为 -1 或 - (插入点)。插入点的值有如下四种情况：

• 搜索值是数组元素，从 0 开始计数，得搜索值的索引值；
• 搜索值不是数组元素，且在数组范围内，从 1 开始计数，得 “ - 插入点索引值”；
• 搜索值不是数组元素，且大于数组内元素，索引值为 - (length + 1);
• 搜索值不是数组元素，且小于数组内元素，索引值为 -1.