Java数组的学习

学习目录：

1. Java数组
2. 数组循环
3. 多维数组

一. Java 数组

数组用于在一个变量中存储多个值，而不是为每个值声明单独的变量。

要声明一个数组，使用方括号定义变量类型：

string[] cars;

声明了一个变量，该变量保存一个字符串数组。要向数组中插入值，可以将值放在大括号内，用逗号分隔。

String[] cars = {"喜欢", "不喜欢", "爱", "不爱"};

声明一个变量，创建一个整数数组：

int[] myNum = {10, 20, 30, 40};

1. 访问数组元素

你可以通过引用索引号来访问数组元素：

Result Size: 815 x 679
public class Main {
  public static void main(String[] args) {
    String[] cars = {"喜欢", "不喜欢", "爱", "不爱"};
    System.out.println(cars[0]); // 输出： 喜欢
  }
}

注意：数组的索引从 0 开始：[0] 是第一个元素，[1] 是第二个元素，以此类推。

2. 更改数组元素

要更改特定元素的值，可以通过引用索引号来实现：

public class Main {
  public static void main(String[] args) {
    String[] cars = {"恋人", "不喜欢", "爱", "不爱"};
    cars[0] = "我们只是朋友";
    System.out.println(cars[0]);
  }
} // 现在输出 cars[0] 时，输出 我们只是朋友 而不是 恋人

3. Array Length

要找出一个数组包含多少个元素，可以使用 length 属性。

public class Main {
  public static void main(String[] args) {
    String[] cars = {"你", "我", "她", "他"，"它"};
    System.out.println(cars.length); // 输出 cars变量有多少个元素，结果是 5
  }
}

二. 数组循环

遍历循环（也叫“迭代”或“循环遍历”）是指通过某种循环结构，逐个访问数据集合中的每个元素。

在编程中，遍历循环通常用于遍历数组、列表、集合等数据结构的所有元素，并对每个元素执行某种操作。

1. 遍历数组

遍历数组是指依次访问数组中的每一个元素，并对每个元素执行某种操作的过程。

• 数组是一个有序的数据集合，每个元素都有一个索引。

• 遍历数组就是从数组的第一个元素开始，通过循环结构逐个访问每个元素，直到数组中的所有元素都被访问过一次。

可以使用 for 循环遍历数组元素，并使用 length 属性来指定循环执行的次数。

以下示例输出 cars 数组中的所有元素:

public class Main {
  public static void main(String[] args) {
    String[] cars = {"你","我","他","它"};
    
    // 使用 for 循环遍历数组
    for (int i = 0; i < cars.length; i++) {// 使用 for 循环通过索引来遍历数组元素,当 i 小于数组的长度时继续循环。
      System.out.println(cars[i]);  // 输出数组中的每个元素,结果： 你
    }                                                    //    我
  }                                                      //    他
}                                                        //    它

三. 多维数组

是包含多个数组的数组。简单来说，它是一个数组，其中的每个元素又是一个数组。因此，多维数组可以用来表示更复杂的数据结构，例如表格、矩阵、网格等。

多维数组的特点：

1. 多维性：多维数组可以包含两个或更多维度。最常见的是二维数组，它表示一个表格或矩阵。更高维的数组则更复杂，例如三维数组可以表示立体的数据结构。
2. 数组元素：多维数组中的每个元素通常是一个数组（或在某些情况下是更深层次的数组）。
3. 使用场景：多维数组非常适合表示需要多个坐标的复杂数据。例如：棋盘、图像数据、网格地图等。

创建一个二维数组，将每个数组放在自己的大括号中：

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

myNumbers 现在是一个包含两个数组作为元素的数组。

1. 访问元素

要访问 myNumbers 数组中的元素，需要指定两个索引：一个用于数组，一个用于数组内部的元素

例1：

public class Main {  
  public static void main(String[] args) {  
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };  
    // int[][] 表示这是一个二维整数数组
    // 定义并初始化一个二维数组 myNumbers，其中：
    // 第一行（myNumbers[0]）是 {1, 2, 3, 4}，包含4个元素
    // 第二行（myNumbers[1]）是 {5, 6, 7}，包含3个元素
    System.out.println(myNumbers[1][2]);  
    // 访问 myNumbers 数组中的第二个数组（索引为 1），并取出该数组中的第三个元素（索引为 2）
    // myNumbers[1] 是 {5, 6, 7}，myNumbers[1][2] 是 7
    // 将 7 输出到控制台
  }
}

注意：数组的索引从 0 开始：[0] 是第一个元素，[1] 是第二个元素，以此类推。

例2：演示了如何修改二维数组中的元素，并输出修改后的值

public class Main {  
  public static void main(String[] args) {  
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };  // 不懂看上例1
    myNumbers[1][2] = 9; 
    // 修改 myNumbers 数组中的元素：
    // myNumbers[1] 是第二行 {5, 6, 7}
    // myNumbers[1][2] 是第三个元素（索引 2），原值是 7
    // 将该元素的值从 7 改为 9
    System.out.println(myNumbers[1][2]);  
    // 输出 myNumbers 数组中第二行第三个元素（索引为 2）的值
    // 因为已经修改为 9，所以输出的是 9，而不是 7
  }
}

注意：数组的索引从 0 开始：[0] 是第一个元素，[1] 是第二个元素，以此类推。

2. 遍历多维数组

可以在一个 for 循环内部使用另一个 for 循环来获取二维数组的元素（我们仍然需要指定两个索引）。

这段话的意思是，遍历二维数组时，可以通过嵌套 for 循环来依次访问数组中的每个元素，在这个过程中需要使用两个索引来定位元素：一个用于行索引，另一个用于列索引。

例1：

public class Main {  
   public static void main(String[] args) {  
     int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };  
     // int[][] 表示这是一个二维整数数组
     // 定义并初始化一个二维数组 myNumbers：
     // myNumbers[0] = {1, 2, 3, 4} （包含4个元素）
     // myNumbers[1] = {5, 6, 7} （包含3个元素）
     for (int i = 0; i < myNumbers.length; ++i) {  
        // 外层循环，遍历二维数组的行。myNumbers.length 是 2，表示数组有两行。
        // i 从 0 到 1，依次表示第一行和第二行。
        
        for(int j = 0; j < myNumbers[i].length; ++j) {  
           // 内层循环，遍历当前行的元素。myNumbers[i].length 是当前行的列数。
           // 对于第一行，myNumbers[0].length 是 4，表示该行有4个元素。
           // 对于第二行，myNumbers[1].length 是 3，表示该行有3个元素。
           
           System.out.println(myNumbers[i][j]);  
           // 输出当前行和列位置的元素
           // 例如，在第一行时，i=0，j 从 0 到 3，依次输出 1, 2, 3, 4
           // 在第二行时，i=1，j 从 0 到 2，依次输出 5, 6, 7
        }
     }
   }
}

可以使用增强的 for 循环（for-each），这种写法通常被认为更易读和书写：

例2：

public class Main {  
  public static void main(String[] args) {  
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} }; 
    // int[][] 指的是二维整形数组
    // 定义并初始化一个二维数组 myNumbers
    // myNumbers[0] = {1, 2, 3, 4} 包含4个元素
    // myNumbers[1] = {5, 6, 7} 包含3个元素

    for (int[] row : myNumbers) {  
      // 使用增强的for循环遍历二维数组 myNumbers
      // 该循环会依次获取 myNumbers 中的每一行，行的数据类型是 int[]（即一维数组）
      // 每次循环，row 代表 myNumbers 中的每一行。第一轮 row 是 {1, 2, 3, 4}，第二轮 row 是 {5, 6, 7}
        
      for (int i : row) {  
        // 对于每一行，使用增强的 for 循环遍历该行中的元素
        // `i` 会依次表示当前行中的每一个元素
       
        System.out.println(i);  
        // 输出当前元素 i
        // 每个元素都会被输出并换行
      }
    }
  }
}