java —— 数组（超详细教程）

介绍：这期讲的是java的原生数组，也就是list（静态空间），空间是写死的；后期的ArrayList是动态数组。我们需要先认识基础的格式，方便后面的ArrayList学习。

一、创建数组

（一）方法一：

1、先声明，再定义长度。

    public static void main(String[] args) {
        // 声明变量
        int[] arr;
        // 创建数组对象
        arr = new int[3];

        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);
        System.out.println("arr[2]="+arr[2]);
        System.out.println("数组的长度是："+ arr.length);
    }

（二）方法二：

1、先声明，再定义长度。

2、写入data（数据）。

public class Ex26_02 {
    public static void main(String[] args) {

        int[] arr = new int[4];
        arr[0] = 1;
        arr[1] = 2;

        System.out.println("arr[0]=" + arr[0]);
        System.out.println("arr[1]=" + arr[1]);
        System.out.println("arr[2]=" + arr[2]);
        System.out.println("arr[3]=" + arr[3]);
        System.out.println("数组的长度是：" + arr.length);
    }
}

（三）方法三：

1、创建的同时，也写入

public class Ex27_02 {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4};
        System.out.println("arr[0]"+arr[0]);
        System.out.println("arr[1]"+arr[1]);
        System.out.println("arr[2]"+arr[2]);
        System.out.println("arr[3]"+arr[3]);
    }
}

二、数组遍历

（优化）for (int j : arr) = （传统）for (int i = 0; i < arr.length; i++) 

下面会对这两种方法进行解释

public class Ex30_02 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int j : arr) {
            System.out.println(j);
        }
    }
}

（一）代码解释：

1. 数组声明和初始化：

   • int[] arr = {1, 2, 3, 4, 5};：
     • 声明并初始化了一个 int 类型的数组 arr。
     • 这里使用了数组初始化的简洁方式，将数组元素 1、2、3、4 和 5 放在花括号 {} 中。

2. 增强型 for 循环（for-each 循环）：

   • for (int j : arr) {...}：
     • 这是 Java 中的增强型 for 循环，也叫 for-each 循环，用于遍历数组或集合中的元素。
     • int j：声明一个新的变量 j，它的类型要与数组元素的类型一致，这里是 int。
     • arr：表示要遍历的数组。

3. 循环体：

   • System.out.println(j);：
     • 对于数组 arr 中的每一个元素，将其存储在变量 j 中，并执行循环体中的操作。
     • 这里的操作是将元素 j 的值输出到控制台。

（二）代码执行过程：

• 当代码开始执行时，会执行以下步骤：
  1. 首先创建一个 int 类型的数组 arr，并存储元素 1、2、3、4 和 5。
  2. 进入 for-each 循环，将数组 arr 的第一个元素 1 赋值给 j，并执行 System.out.println(j);，输出 1。
  3. 接着将数组 arr 的第二个元素 2 赋值给 j，并输出 2。
  4. 重复这个过程，依次输出 3、4 和 5。

（三）优点：

• 这种增强型 for 循环具有以下优点：
  • 简洁性：相比于传统的 for 循环，不需要使用索引变量和 arr.length 来控制循环，代码更简洁。
  • 易读性：代码的意图更加清晰，更容易理解，特别是对于只需要遍历元素而不需要操作数组索引的情况。

（四）对比传统的 for 循环：

• 传统的 for 循环实现相同功能的代码如下：

int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

（五）传统 for 循环解释：

• for (int i = 0; i < arr.length; i++) {...}：
  • 使用 int i = 0 初始化一个索引变量 i。
  • i < arr.length 作为循环条件，确保不超出数组长度。
  • i++ 用于更新索引变量。
  • arr[i] 用于访问数组中索引为 i 的元素。

三、数组最值

public class Ex31_02 {
    public static void main(String[] args) {
        // 创建数组
        int[] arr = {4,1,6,5,9,8};
        // 最大值赋值，调用函数
        int max = getMax(arr);
        // 打印最大值
        System.out.println("max="+max);
    }
    static int getMax(int[] arr){
        // 定义数组的第一个为最大值
        int max = arr[0];
        // 因为第一个已经使用了，我们不需要让 x=0;减少循环多一次
        for (int x=1;x<arr.length;x++){
            if(arr[x]>max){
                max=arr[x];
            }
        }
        return max;
    }

}

 四、数组排序

public class Ex32_02 {
    public static void main(String[] args) {
        int[] arr = {9, 8, 3, 5, 2};
        System.out.print("冒泡排序前：");
        printArray(arr);
        bubbleSort(arr);
        System.out.print("冒泡排序后：");
        printArray(arr);
    }

    // 定义数组的打印方法
    public static void printArray(int[] arr) {
        // 循环遍历数组
        for (int j : arr) {
            System.out.print(j + " ");
        }
        System.out.print("\n");
    }

    // 定义对数组的排序方法
    public static void bubbleSort(int[] arr) {
        // 定义外层循环
        for (int i = 0; i < arr.length - 1; i++) {              // 0下标开始，取到最后一个
            // 定义内层循环，-i-i:是因为最后一个数已经交换完，不需要再进行交换
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j]>arr[j+1]){
                    // 下面三行代码用于交换两个元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.print("第"+(i+1)+"轮排序后：");
            printArray(arr);
        }
    }
}

（一）冒泡排序的实现细节：

• 外层循环（循环多少次）：

  • for (int i = 0; i < arr.length - 1; i++) {...}：
    • 控制排序的轮数，arr.length - 1 表示最多需要 arr.length - 1 轮排序，因为每一轮排序会将当前未排序部分的最大元素 “浮” 到末尾。

• 内层循环（交换多少次）：

  • for (int j = 0; j < arr.length - i - 1; j++) {...}：
    • 比较相邻元素并交换。
    • arr.length - i - 1 表示每一轮排序后，末尾的 i 个元素已经是有序的，无需再比较。

• 元素交换：

  • if (arr[j] > arr[j + 1]) {...}：
    • 比较相邻元素 arr[j] 和 arr[j + 1]，如果 arr[j] 大于 arr[j + 1]，则交换它们的位置。
    • int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp;：使用临时变量 temp 交换元素位置。

五、多维数组

public class Ex33_02 {
    public static void main(String[] args) {
        // 创建多维数组
        int[][] arr = new int[3][];
        arr[0] = new int[]{11, 12};
        arr[1] = new int[]{21, 22, 23};
        arr[2] = new int[]{31, 32, 33, 34};

        //  总销售额
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            // 组销售额
            int groupSum = 0;
            for (int j = 0; j < arr[i].length; j++) {
                groupSum += arr[i][j];
            }
            sum += groupSum;
            System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + "万元。");

        }
        System.out.println("总销售额为：" + sum + "万元");
    }
}

（一）代码解释：

1. 类和主方法：

   • public class Ex33_02：定义了一个公共类 Ex33_02。
   • public static void main(String[] args)：程序的入口点，程序从这里开始执行。

2. 多维数组的创建和初始化：

   • int[][] arr = new int[3][];：

     • 创建了一个二维数组 arr，其中第一维的长度为 3，表示有 3 个小组。
     • 这里只指定了第一维的长度，第二维的长度未指定，所以 arr 是一个锯齿状的数组，即每个子数组的长度可以不同。

   • arr[0] = new int[]{11, 12};：

     • 为第一组创建一个包含两个元素的子数组，元素为 11 和 12。

   • arr[1] = new int[]{21, 22, 23};：

     • 为第二组创建一个包含三个元素的子数组，元素为 21、22 和 23。

   • arr[2] = new int[]{31, 32, 33, 34};：

     • 为第三组创建一个包含四个元素的子数组，元素为 31、32、33 和 34。

3. 销售额计算和输出：

   • int sum = 0;：

     • 初始化一个变量 sum，用于存储总销售额。

   • 外层 for 循环：

     • for (int i = 0; i < arr.length; i++) {...}：
       • 遍历每一个小组，arr.length 是第一维的长度，这里为 3。

   • 内层 for 循环：

     • for (int j = 0; j < arr[i].length; j++) {...}：
       • 遍历每个小组的元素。
       • arr[i].length 是第 i 个子数组的长度。

   • groupSum += arr[i][j];：

     • 计算每个小组的销售额 groupSum，将子数组中的元素相加。

   • sum += groupSum;：

     • 将每个小组的销售额累加到总销售额 sum 中。

   • System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + "万元。");：

     • 输出每个小组的销售额。

   • System.out.println("总销售额为：" + sum + "万元");：

     • 输出总销售额。