Java中数组以及操作数组的工具类Arrays

一、Java中的数组

        数组是 Java 中用于存储固定数量同类型元素的数据结构。

// 声明方式（推荐第一种）
int[] arr1;        // 标准写法
int arr2[];        // C风格（不推荐）

// 初始化方式
int[] arr3 = new int[5];            // 动态初始化（默认值：int为0）
int[] arr4 = {1, 2, 3, 4, 5};       // 静态初始化
int[] arr5 = new int[]{10, 20, 30}; // 匿名数组初始化

所有元素在内存中连续存储，通过索引（从 0 开始）访问。

1.数组的核心特征

• 固定长度：创建后长度不可变
• 同类型元素：所有元素必须是相同数据类型
• 索引访问：索引范围：0 到 length-1
• 对象类型：数组本身是对象（继承自 java.lang.Object）

2.声明与初始化

        在Java中，数组在声明时不能直接定义大小。声明数组只是定义了数组变量的类型（即一个可以指向数组对象的引用），而并没有实际创建数组对象。创建数组对象（即分配内存空间）需要在初始化时进行，此时才指定数组的大小。

// 声明方式（推荐第一种）
int[] arr1;        // 标准写法
int arr2[];        // C风格（不推荐）

// 初始化方式
int[] arr3 = new int[5];            // 动态初始化（默认值：int为0）
int[] arr4 = {1, 2, 3, 4, 5};       // 静态初始化
int[] arr5 = new int[]{10, 20, 30}; // 匿名数组初始化

声明只确定类型
声明语句如 int[] arr; 仅表示 arr 将引用一个整数数组，不分配内存。

初始化决定大小

• new int[size] → 显式定义大小
• {elem1, elem2...} → 隐含大小（元素个数）
• new int[]{...} → 隐含大小

3.多维数组

// 二维数组声明
int[][] matrix = new int[3][4]; // 3行4列

// 初始化
int[][] grid = {
    {1, 2, 3},
    {4, 5},
    {6, 7, 8, 9}
};

// 访问元素
System.out.println(grid[1][0]); // 输出：4

注意：Java 支持不规则数组（每行长度可不同）

二、数组的关键操作

获取长度

int len = arr4.length; // 返回5

遍历数组

// 传统for循环
for (int i = 0; i < arr4.length; i++) {
    System.out.println(arr4[i]);
}

// 增强for循环
for (int num : arr4) {
    System.out.println(num);
}

三、数组的常见异常

ArrayIndexOutOfBoundsException：访问无效索引（如 arr[-1] 或 arr[arr.length]）

NullPointerException：操作未初始化的数组引用（如 int[] arr; arr[0]=1;）

四、数组的工具类Arrays

        在 Java 中，java.util.Arrays 是一个专门用于操作数组的工具类，提供了丰富的静态方法来简化数组的常见操作（如排序、搜索、比较、填充等）。以下是其主要功能的详细说明及示例：

1. 数组转字符串

• Arrays.toString(array)：将一维数组转换为可读字符串
• Arrays.deepToString(array)：支持多维数组

int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr)); // 输出: [1, 2, 3]

int[][] matrix = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(matrix)); // 输出: [[1, 2], [3, 4]]

2.数组排序

• Arrays.sort(array)：对基本类型/对象数组升序排序（快速排序）
• Arrays.sort(array, comparator)：自定义排序规则
• Arrays.parallelSort(array)：并行排序（大数据量更高效）

int[] nums = {5, 3, 9, 1};
Arrays.sort(nums); // 结果: [1, 3, 5, 9]

String[] names = {"John", "Alice", "Bob"};
Arrays.sort(names, (a, b) -> b.compareTo(a)); // 按字母降序

3. 二分查找

• Arrays.binarySearch(array, key)：在已排序数组中查找元素，返回索引（未找到返回负数）

int[] sorted = {10, 20, 30, 40};
int index = Arrays.binarySearch(sorted, 30); // 返回 2

使用二分搜索算法在指定的int数组中搜索指定的值。

在调用此调用之前，必须对数组进行排序（如通过sort（int[]）方法）。如果没有排序，结果是未定义的。如果数组包含多个具有指定值的元素，则不能保证找到哪个元素。

在返回值方面，如果搜索键包含在数组中，则搜索键的索引；否则，（-（插入点）- 1）。插入点定义为将键插入数组的点：第一个大于键的元素的索引，如果数组中的所有元素都小于指定的键，则为a.length。注意，这保证了当且仅当找到键时返回值为>= 0

4. 数组填充

• Arrays.fill(array, value)：用指定值填充整个数组
• Arrays.fill(array, start, end, value)：填充指定区间

char[] chars = new char[3];
Arrays.fill(chars, 'A'); // 结果: ['A', 'A', 'A']
Arrays.fill(chars, 1, 3, 'B'); // 结果: ['A', 'B', 'B']

5. 数组比较

• Arrays.equals(array1, array2)：比较一维数组内容
• Arrays.deepEquals(array1, array2)：比较多维数组

int[] a = {1, 2}, b = {1, 2};
System.out.println(Arrays.equals(a, b)); // true

int[][] x = {{1}}, y = {{1}};
System.out.println(Arrays.deepEquals(x, y)); // true

6. 数组复制

• Arrays.copyOf(original, newLength)：复制数组并指定新长度
• Arrays.copyOfRange(original, from, to)：复制指定区间

int[] source = {1, 2, 3};
int[] copy1 = Arrays.copyOf(source, 2); // [1, 2]
int[] copy2 = Arrays.copyOfRange(source, 1, 3); // [2, 3]

五、数组的工具类Arrays操作自定义类对象

        Arrays 工具类的大部分方法同样适用于自定义类的对象数组，但使用时需要注意几个关键点：

1.Arrays.toString() 和 Arrays.deepToString()

需要自定义类重写 toString() 方法，否则输出的是对象地址（如 Person@1a2b3c）。

class Person {
    String name;
    int age;
    
    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}

Person[] people = {new Person("Alice", 30), new Person("Bob", 25)};
System.out.println(Arrays.toString(people)); 
// 输出: [Alice(30), Bob(25)]

2.Arrays.fill()

直接填充对象引用（所有元素指向同一个对象）：

Person[] arr = new Person[3];
Arrays.fill(arr, new Person("Default", 0)); 
// 所有元素共享同一个Person实例

3.Arrays.copyOf() 和 Arrays.copyOfRange()

执行浅拷贝（复制对象引用，不复制对象本身）：

Person[] original = {new Person("Alice", 30)};
Person[] copy = Arrays.copyOf(original, 1);

copy[0].name = "Bob";
System.out.println(original[0].name); // 输出 "Bob"（原对象被修改）

4.Arrays.sort()

必须提供排序规则，否则抛出 ClassCastException：

方案一：自定义类实现 Comparable 接口

class Person implements Comparable<Person> {
    // ...其他代码...
    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age); // 按年龄排序
    }
}
Arrays.sort(people); // 直接使用

方案二：传入 Comparator 比较器

// 按姓名排序
Arrays.sort(people, (p1, p2) -> p1.name.compareTo(p2.name));