Java学习---Arrays类

在Java中，Arrays类是java.util包中的一个工具类 ，专门为数组操作提供了一系列静态方法。它不是用来创建数组的，而是用来操作和处理已存在的数组。

首先澄清一个常见混淆：

概念	说明	示例
数组 (Array)	Java语言内置的数据结构	int[] arr = new int[5];
Arrays类	操作数组的工具类	Arrays.sort(arr);

Arrays类核心方法详解

1. 导入Arrays类

import java.util.Arrays;  // 必须导入才能使用

2.数组转字符串

public class ArraysToStringDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        
        // 1. Arrays.toString() - 一维数组转字符串
        String str = Arrays.toString(arr);
        System.out.println("toString(): " + str);  // [1, 2, 3, 4, 5]
        
        // 2. Arrays.deepToString() - 多维数组转字符串
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        String Str = Arrays.deepToString(matrix);
        System.out.println("deepToString(): " + Str);  // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
        
    }
}

3. 数组的创建与填充

Array.fill

public class ArraysDemo1 {
    public static void main(String[] args) {
        // Arrays.fill() - 填充数组
        
        // 填充整个数组
        int[] arr1 = new int[5];
        Arrays.fill(arr1, 100);  // 所有元素变为100
        System.out.println(Arrays.toString(arr1));  // [100, 100, 100, 100, 100]
        
        // 填充指定范围 [from, to)
        int[] arr2 = new int[10];
        Arrays.fill(arr2, 2, 6, 99);  // 将索引[2,6)的元素填充为99
        System.out.println(Arrays.toString(arr2));  // [0, 0, 99, 99, 99, 99, 0, 0, 0, 0]
        
        // 创建时直接填充（Java 8+）
        int[] arr3 = new int[5];
        Arrays.setAll(arr3, i -> i * 2);  // [0, 2, 4, 6, 8]
        
        // 并行填充（大数据量性能更好）
        int[] arr4 = new int[1_000_000];
        Arrays.parallelSetAll(arr4, i -> i % 10);
    }
}

4. 数组排序

public class ArraysSortDemo {
    public static void main(String[] args) {
        // 基本数据类型排序
        int[] numbers = {34, 12, 89, 5, 67};
        Arrays.sort(numbers);  // 升序排序
        System.out.println("排序后: " + Arrays.toString(numbers));  // [5, 12, 34, 67, 89]
        
        // 部分排序（对指定范围排序）
        int[] arr = {34, 12, 89, 5, 67, 23, 11};
        Arrays.sort(arr, 2, 6);  // 只排序索引[2,6)的元素
        System.out.println("部分排序: " + Arrays.toString(arr));  // [34, 12, 5, 23, 67, 89, 11]
        
        // 字符串数组排序
        String[] names = {"张三", "李四", "王五", "赵六"};
        Arrays.sort(names);
        System.out.println("名字排序: " + Arrays.toString(names));  // 按Unicode排序
        
}

5. 数组搜索

public class ArraysSearchDemo {
    public static void main(String[] args) {
        //  重要：binarySearch要求数组必须已排序！
        
        int[] arr = {10, 20, 30, 40, 50, 60};
        
        // 二分查找（返回索引，找不到返回负数）
        int index = Arrays.binarySearch(arr, 30);
        System.out.println("30的索引: " + index);  // 2
        
        index = Arrays.binarySearch(arr, 35);
        System.out.println("35的索引: " + index);  // -4（插入点：-索引-1）
        
        // 在指定范围内搜索
        index = Arrays.binarySearch(arr, 1, 4, 20);  // 在[1,4)范围内搜索
        System.out.println("20在范围[1,4)的索引: " + index);  // 1
        
        // 字符串数组搜索
        String[] names = {"apple", "banana", "cherry", "date"};
        Arrays.sort(names);  // 先排序！
        int strIndex = Arrays.binarySearch(names, "cherry");
        System.out.println("cherry的索引: " + strIndex);  // 2
       
    }
}

6. 数组比较与相等性判断

public class ArraysCompareDemo {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {1, 2, 3, 4, 5};
        int[] arr3 = {1, 2, 3, 4};
        int[] arr4 = {5, 4, 3, 2, 1};
        
        // 1. Arrays.equals() - 比较数组内容是否相等
        boolean isEqual = Arrays.equals(arr1, arr2);
        System.out.println("arr1 equals arr2: " + isEqual);  // true
        
        isEqual = Arrays.equals(arr1, arr3);
        System.out.println("arr1 equals arr3: " + isEqual);  // false（长度不同）
        
        // 2. Arrays.compare() - 比较数组的字典顺序（Java 9+）
        // 返回负数、零、正数表示小于、等于、大于
        int result = Arrays.compare(arr1, arr4);
        System.out.println("arr1 compare arr4: " + result);  // 负数（arr1 < arr4）
        
    }
}

7. 数组复制

public class ArraysCopyDemo {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        
        // 1. Arrays.copyOf() - 复制指定长度
        int[] copy1 = Arrays.copyOf(original, 5);  // 复制前5个元素
        System.out.println("copyOf(5): " + Arrays.toString(copy1));  // [1, 2, 3, 4, 5]
        
        int[] copy2 = Arrays.copyOf(original, 15);  // 长度大于原数组，多余位置补0
        System.out.println("copyOf(15): " + Arrays.toString(copy2));  // 后面补0
        
        // 2. Arrays.copyOfRange() - 复制指定范围
        int[] copy3 = Arrays.copyOfRange(original, 2, 7);  // 复制[2,7)索引的元素
        System.out.println("copyOfRange(2,7): " + Arrays.toString(copy3));  // [3, 4, 5, 6, 7]
        
        // 3. 与System.arraycopy()的比较
        int[] copy4 = new int[5];
        System.arraycopy(original, 3, copy4, 0, 5);  // 从original[3]开始复制5个元素到copy4
        System.out.println("System.arraycopy: " + Arrays.toString(copy4));  // [4, 5, 6, 7, 8]
        
    }
}

时间复杂度对比

操作	普通方法	Arrays类方法	时间复杂度
排序	手动实现	Arrays.sort()	O(n log n)
搜索（无序）	线性搜索	Arrays.binarySearch()	O(log n)（需先排序）
比较	逐个比较	Arrays.equals()	O(n)
复制	循环复制	Arrays.copyOf()	O(n)