Java 数组详解

在 Java 编程中，数组是一种基础且重要的数据结构，用于存储固定大小的同类型元素。以下从多个维度详细解析 Java 数组的核心概念、使用方法及注意事项：

一、数组的基本概念

1. 定义与特性
   • 固定长度：数组一旦创建，大小不可变。
   • 同类型元素：只能存储声明时指定的数据类型（基本类型或引用类型）。
   • 连续内存：元素在内存中连续存储，支持快速随机访问。
2. 声明与初始化

   // 静态初始化：指定元素值，长度由元素个数决定
   int[] arr1 = {1, 2, 3};  // 推荐写法
   int arr2[] = new int[]{4, 5, 6};  // C风格写法
   
   // 动态初始化：指定长度，元素默认初始化为0（基本类型）或null（引用类型）
   int[] arr3 = new int[5];  // 长度为5的int数组，元素默认值为0
   

    

二、数组的访问与操作

1. 元素访问
   • 通过索引（从 0 开始）访问元素：
      

     int[] arr = {10, 20, 30};
     System.out.println(arr[0]);  // 输出10
     arr[2] = 40;  // 修改索引2的元素值
     

      
2. 遍历方式
   • 普通 for 循环：
      

     for (int i = 0; i < arr.length; i++) {
         System.out.println(arr[i]);
     }
     

      
   • 增强 for 循环（foreach）：
      

     for (int num : arr) {
         System.out.println(num);
     }
     

      
   • Java 8 Stream API：
      

     Arrays.stream(arr).forEach(System.out::println);
     

      

三、多维数组

1. 二维数组
   • 本质是 “数组的数组”，每个元素是一个一维数组。
    

   // 静态初始化
   int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
   
   // 动态初始化
   int[][] arr = new int[3][2];  // 3行2列的二维数组
   
   // 不规则二维数组（每行长度可不同）
   int[][] irregular = new int[3][];
   irregular[0] = new int[2];
   irregular[1] = new int[3];
   

    
2. 多维数组的遍历
    

   for (int i = 0; i < matrix.length; i++) {
       for (int j = 0; j < matrix[i].length; j++) {
           System.out.print(matrix[i][j] + " ");
       }
       System.out.println();
   }
   

    

四、数组的常用操作

1. 数组长度获取
    

   int length = arr.length;  // 返回数组的长度
   

    
2. 数组复制
   • 浅拷贝（复制引用，共享对象）：
      

     int[] arr1 = {1, 2, 3};
     int[] arr2 = arr1;  // 引用复制，arr1和arr2指向同一对象
     

      
   • 深拷贝（复制值，创建新对象）：
      

     int[] arr3 = Arrays.copyOf(arr1, arr1.length);  // 使用Arrays工具类
     System.arraycopy(arr1, 0, arr3, 0, arr1.length);  // 使用System类
     

      
3. 数组排序

   int[] arr = {3, 1, 4};
   Arrays.sort(arr);  // 升序排序，修改原数组
   

    
4. 数组查找

   int index = Arrays.binarySearch(arr, 4);  // 二分查找，需先排序
   

    

五、数组与泛型

• 数组协变（Covariance）：
  数组支持子类数组赋值给父类数组变量，但运行时可能抛出ArrayStoreException。
   

  Object[] objArray = new String[5];
  objArray[0] = 123;  // 编译通过，运行时抛出ArrayStoreException
  

   
• 泛型数组限制：
  不能直接创建泛型数组，需通过类型擦除或反射实现。
   

  // 错误写法
  List<String>[] listArray = new List<String>[5];
  
  // 正确写法（使用通配符）
  List<?>[] listArray = new List<?>[5];
  

   

六、数组与集合的转换

1. 数组转集合
    

   String[] arr = {"a", "b", "c"};
   List<String> list = Arrays.asList(arr);  // 返回固定大小的List，不可增删
   List<String> mutableList = new ArrayList<>(Arrays.asList(arr));  // 可修改的List
   

    
2. 集合转数组
    

   List<String> list = Arrays.asList("a", "b", "c");
   String[] arr = list.toArray(new String[0]);  // 推荐使用空数组参数
   

    

七、常见问题与注意事项

1. 数组越界异常
   • 访问超出索引范围的元素会抛出ArrayIndexOutOfBoundsException。
    

   int[] arr = new int[3];
   System.out.println(arr[3]);  // 错误：索引最大为2
   

    
2. 空指针异常
   • 未初始化的数组直接使用会抛出NullPointerException。

   int[][] arr;
   arr[0] = new int[2];  // 错误：arr未初始化
   

    
3. 性能考量
   • 数组适合随机访问（时间复杂度 O (1)），但插入 / 删除效率低（需移动元素）。

八、Java 8+ 的数组增强

1. Stream API
    

   int[] arr = {1, 2, 3};
   int sum = Arrays.stream(arr).sum();  // 求和
   int max = Arrays.stream(arr).max().getAsInt();  // 最大值
   

    
2. 并行操作
    

   Arrays.parallelSort(arr);  // 并行排序，适合大数据量
   

    

总结

数组是 Java 中最基础的数据结构之一，具有高效的随机访问能力，但长度固定、类型单一。在实际开发中，需根据场景选择合适的数组操作方式，并注意避免常见的运行时异常。Java 8+ 的 Stream API 和并行操作进一步提升了数组的处理效率，使其在现代编程中仍保持重要地位。