• Java从入门到精通-数组（三）

    0. 数组

    ![在这里插入图片描述](https://img-blog.csdnimg.cn/1fbcd1668f4d42bf90e134d8d7bf2931.png

    1. 数组概述

    练习1： 创建一个整数数组，存储喜欢的5个数字，并编写代码打印出这些数字。

    创建一个整数数组
    1. public class Main {
    2.     public static void main(String[] args) {
    3.         // 创建一个整数数组，存储5个喜欢的数字
    4.         int[] favoriteNumbers = {7, 22, 14, 42, 3};
    5.  
    6.         // 打印出这些数字
    7.         System.out.println("我喜欢的数字：");
    8.         for (int i = 0; i < favoriteNumbers.length; i++) {
    9.             System.out.println(favoriteNumbers[i]);
    10.         }
    11.     }
    12. }
    案例分析：
    1. 在这个练习中，我们首先创建了一个名为 favoriteNumbers 的整数数组，其中包含了5个我们喜欢的数字。
    2. 使用 for 循环遍历数组，通过索引访问数组中的每个元素，并使用 System.out.println() 方法将它们打印出来。
    案例总结：
    • 数组是一种数据结构，用于存储一组相同数据类型的元素，可以按顺序访问。
    • 创建数组时，我们需要指定数组的类型和长度，并可以通过初始化列表来初始化数组的元素。
    • 遍历数组是通过循环来实现的，通常使用 for 循环或增强型 for-each 循环来访问数组中的元素。
    • 数组是在Java中常见的数据结构之一，用于存储和处理大量的数据。在本例中，我们成功地创建了一个整数数组并打印了数组中的元素。这是数组概述中的一个简单示例，帮助我们理解了数组的基本概念和用法。

    2. 一维数组

    练习2： 创建一个字符串数组，包含一些水果的名称，然后使用循环遍历并打印数组中的水果名称。

    创建一个字符串数组并遍历打印
    1. public class Main {
    2.     public static void main(String[] args) {
    3.         // 创建一个字符串数组，包含一些水果的名称
    4.         String[] fruits = {"苹果", "香蕉", "橙子", "葡萄", "樱桃"};
    5.  
    6.         // 使用循环遍历并打印数组中的水果名称
    7.         System.out.println("水果列表：");
    8.         for (int i = 0; i < fruits.length; i++) {
    9.             System.out.println(fruits[i]);
    10.         }
    11.     }
    12. }
    案例分析：
    1. 在这个练习中，我们首先创建了一个名为 fruits 的字符串数组，其中包含了一些水果的名称。
    2. 使用 for 循环遍历数组，通过索引访问数组中的每个元素，并使用 System.out.println() 方法将它们打印出来。
    案例总结：
    • 数组是一种数据结构，用于存储一组相同数据类型的元素，可以按顺序访问。
    • 在本例中，我们创建了一个字符串数组，用于存储水果的名称。
    • 使用循环遍历数组是一种常见的操作，可以使用 for 循环或增强型 for-each 循环来访问数组中的元素。
    • 数组在许多编程场景中都非常有用，它们允许我们有效地存储和处理多个数据元素。
    • 在这个示例中，我们成功地创建了一个字符串数组并打印了数组中的水果名称，这有助于理解数组的基本用法。

    练习3： 编写一个程序，接受用户输入的一组数字，然后计算它们的平均值。

    计算一组数字的平均值
    1. import java.util.Scanner;
    2.  
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         Scanner scanner = new Scanner(System.in);
    6.  
    7.         // 提示用户输入一组数字
    8.         System.out.print("请输入一组数字，以空格分隔：");
    9.         String input = scanner.nextLine();
    10.  
    11.         // 使用空格分割输入字符串，将数字存储到数组中
    12.         String[] numbersAsString = input.split(" ");
    13.         double[] numbers = new double[numbersAsString.length];
    14.  
    15.         for (int i = 0; i < numbersAsString.length; i++) {
    16.             numbers[i] = Double.parseDouble(numbersAsString[i]);
    17.         }
    18.  
    19.         // 计算数字的平均值
    20.         double sum = 0;
    21.         for (double number : numbers) {
    22.             sum += number;
    23.         }
    24.  
    25.         double average = sum / numbers.length;
    26.  
    27.         // 打印平均值
    28.         System.out.println("这组数字的平均值是：" + average);
    29.  
    30.         // 关闭Scanner
    31.         scanner.close();
    32.     }
    33. }
    案例分析：
    1. 在这个练习中，我们首先使用 Scanner 类接受用户的输入，要求用户输入一组数字，以空格分隔。
    2. 输入的字符串被分割成数字字符串数组，并通过循环将其转换为 double 类型的数组。
    3. 我们计算数字的总和，然后通过除以数字的数量来计算平均值。
    4. 最后，我们打印出计算得到的平均值。
    案例总结：
    • 这个示例演示了如何使用Java中的数组来存储一组数字，以及如何计算这些数字的平均值。
    • Scanner 类用于接受用户输入，通过 split() 方法将输入字符串分割成数组，然后通过循环将字符串转换为数字。
    • 数组是一种有助于组织和处理大量数据的强大工具，它们允许我们进行各种数学和统计计算。
    • 通过这个练习，读者可以学习如何处理用户输入和使用数组来进行基本的数学操作。

    3. 二维数组

    练习4： 创建一个二维整数数组来表示一个九宫格数独游戏的初始状态，并编写代码打印出数独的初始状态。

    创建并打印九宫格数独游戏的初始状态
    1. public class Main {
    2.     public static void main(String[] args) {
    3.         // 创建一个二维整数数组来表示数独游戏的初始状态
    4.         int[][] sudoku = {
    5.             {5, 3, 0, 0, 7, 0, 0, 0, 0},
    6.             {6, 0, 0, 1, 9, 5, 0, 0, 0},
    7.             {0, 9, 8, 0, 0, 0, 0, 6, 0},
    8.             {8, 0, 0, 0, 6, 0, 0, 0, 3},
    9.             {4, 0, 0, 8, 0, 3, 0, 0, 1},
    10.             {7, 0, 0, 0, 2, 0, 0, 0, 6},
    11.             {0, 6, 0, 0, 0, 0, 2, 8, 0},
    12.             {0, 0, 0, 4, 1, 9, 0, 0, 5},
    13.             {0, 0, 0, 0, 8, 0, 0, 7, 9}
    14.         };
    15.  
    16.         // 打印数独的初始状态
    17.         System.out.println("数独的初始状态：");
    18.         printSudoku(sudoku);
    19.     }
    20.  
    21.     // 辅助方法：打印数独
    22.     public static void printSudoku(int[][] sudoku) {
    23.         for (int i = 0; i < sudoku.length; i++) {
    24.             for (int j = 0; j < sudoku[i].length; j++) {
    25.                 System.out.print(sudoku[i][j] + " ");
    26.             }
    27.             System.out.println();
    28.         }
    29.     }
    30. }
    案例分析：
    1. 在这个练习中，我们创建了一个名为 sudoku 的二维整数数组，用于表示数独游戏的初始状态。数组中的0表示空格，其他数字表示已知的数。
    2. 我们使用 printSudoku 方法来打印数独的初始状态。该方法通过嵌套循环遍历二维数组，并逐行打印数独的格子。
    案例总结：
    • 数组是一种用于存储和处理多维数据的强大工具。在这个示例中，我们使用二维整数数组来表示数独游戏的初始状态。
    • 使用嵌套循环可以有效地遍历二维数组的所有元素，并按照需要进行操作。
    • 数独游戏是一个经典的数学谜题，通过这个练习，读者可以学习如何使用数组来表示和处理游戏的状态

    练习5： 编写一个程序，生成一个3x3的随机迷宫地图，其中包括起点、终点和墙壁。

    生成随机迷宫地图
    1. import java.util.Random;
    2.  
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         // 定义迷宫地图的大小
    6.         int rows = 3;
    7.         int cols = 3;
    8.  
    9.         // 创建一个二维字符数组来表示迷宫地图
    10.         char[][] maze = generateMaze(rows, cols);
    11.  
    12.         // 打印迷宫地图
    13.         System.out.println("随机生成的迷宫地图：");
    14.         printMaze(maze);
    15.     }
    16.  
    17.     // 辅助方法：生成随机迷宫地图
    18.     public static char[][] generateMaze(int rows, int cols) {
    19.         char[][] maze = new char[rows][cols];
    20.         Random random = new Random();
    21.  
    22.         // 随机设置起点、终点和墙壁
    23.         for (int i = 0; i < rows; i++) {
    24.             for (int j = 0; j < cols; j++) {
    25.                 int randomNumber = random.nextInt(3); // 生成0到2之间的随机数
    26.                 if (randomNumber == 0) {
    27.                     maze[i][j] = 'S'; // 起点
    28.                 } else if (randomNumber == 1) {
    29.                     maze[i][j] = 'E'; // 终点
    30.                 } else {
    31.                     maze[i][j] = '#'; // 墙壁
    32.                 }
    33.             }
    34.         }
    35.  
    36.         return maze;
    37.     }
    38.  
    39.     // 辅助方法：打印迷宫地图
    40.     public static void printMaze(char[][] maze) {
    41.         for (int i = 0; i < maze.length; i++) {
    42.             for (int j = 0; j < maze[i].length; j++) {
    43.                 System.out.print(maze[i][j] + " ");
    44.             }
    45.             System.out.println();
    46.         }
    47.     }
    48. }
    案例分析：
    1. 在这个练习中，我们定义了迷宫地图的大小，并创建了一个二维字符数组 maze 用于表示迷宫地图。
    2. 使用 Random 类来生成随机的起点、终点和墙壁。我们通过生成0到2之间的随机数来确定地图上的元素，其中0表示起点，1表示终点，2表示墙壁。
    3. 最后，我们通过 printMaze 方法打印生成的迷宫地图。
    案例总结：
    • 这个示例演示了如何使用Java中的二维字符数组来生成随机迷宫地图。
    • Random 类用于生成随机数，帮助创建不同的迷宫地图。
    • 数组在游戏开发、地图生成和模拟等应用中经常被用来表示复杂的场景和状态。
    • 通过这个练习，读者可以学习如何使用数组来构建随机生成的迷宫地图，这有助于理解数组在游戏编程中的应用。
    4. 数组的基本操作

    练习6： 编写一个程序，接受用户输入的一组数字，并查找其中的最大值和最小值。

    查找一组数字的最大值和最小值
    1. import java.util.Scanner;
    2.  
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         Scanner scanner = new Scanner(System.in);
    6.  
    7.         // 提示用户输入一组数字，以空格分隔
    8.         System.out.print("请输入一组数字，以空格分隔：");
    9.         String input = scanner.nextLine();
    10.  
    11.         // 使用空格分割输入字符串，将数字存储到数组中
    12.         String[] numbersAsString = input.split(" ");
    13.         double[] numbers = new double[numbersAsString.length];
    14.  
    15.         for (int i = 0; i < numbersAsString.length; i++) {
    16.             numbers[i] = Double.parseDouble(numbersAsString[i]);
    17.         }
    18.  
    19.         // 查找最大值和最小值
    20.         double max = findMax(numbers);
    21.         double min = findMin(numbers);
    22.  
    23.         // 打印最大值和最小值
    24.         System.out.println("最大值是：" + max);
    25.         System.out.println("最小值是：" + min);
    26.  
    27.         // 关闭Scanner
    28.         scanner.close();
    29.     }
    30.  
    31.     // 辅助方法：查找数组中的最大值
    32.     public static double findMax(double[] numbers) {
    33.         double max = numbers[0];
    34.         for (double number : numbers) {
    35.             if (number > max) {
    36.                 max = number;
    37.             }
    38.         }
    39.         return max;
    40.     }
    41.  
    42.     // 辅助方法：查找数组中的最小值
    43.     public static double findMin(double[] numbers) {
    44.         double min = numbers[0];
    45.         for (double number : numbers) {
    46.             if (number < min) {
    47.                 min = number;
    48.             }
    49.         }
    50.         return min;
    51.     }
    52. }
    案例分析：
    1. 在这个练习中，我们使用 Scanner 类接受用户的输入，要求用户输入一组数字，以空格分隔。
    2. 输入的字符串被分割成数字字符串数组，并通过循环将其转换为 double 类型的数组。
    3. 我们编写两个辅助方法 findMax 和 findMin 来分别查找数组中的最大值和最小值。
    4. 最后，我们打印出找到的最大值和最小值。
    案例总结：
    • 这个示例演示了如何使用Java来查找一组数字的最大值和最小值。
    • Scanner 类用于接受用户输入，通过 split() 方法将输入字符串分割成数组，然后通过循环将字符串转换为数字。
    • 数组是一种有助于存储和处理多个数据元素的工具，可以用于各种数学和统计计算。
    • 通过这个练习，读者可以学习如何处理用户输入并使用数组来进行基本的数学操作，如查找最大值和最小值。

    练习7： 创建两个整数数组，分别表示两个向量的坐标，然后编写代码计算这两个向量的点积（内积）。

    计算两个向量的点积
    1. public class Main {
    2.     public static void main(String[] args) {
    3.         // 创建两个整数数组，分别表示两个向量的坐标
    4.         int[] vector1 = {2, 3, -1};
    5.         int[] vector2 = {1, -2, 2};
    6.  
    7.         // 计算两个向量的点积
    8.         int dotProduct = calculateDotProduct(vector1, vector2);
    9.  
    10.         // 打印点积结果
    11.         System.out.println("两个向量的点积是：" + dotProduct);
    12.     }
    13.  
    14.     // 辅助方法：计算两个向量的点积
    15.     public static int calculateDotProduct(int[] vector1, int[] vector2) {
    16.         if (vector1.length != vector2.length) {
    17.             throw new IllegalArgumentException("向量长度不一致");
    18.         }
    19.  
    20.         int dotProduct = 0;
    21.         for (int i = 0; i < vector1.length; i++) {
    22.             dotProduct += vector1[i] * vector2[i];
    23.         }
    24.  
    25.         return dotProduct;
    26.     }
    27. }
    案例分析：
    1. 在这个练习中，我们首先创建了两个整数数组 vector1 和 vector2，它们分别表示两个向量的坐标。
    2. 我们编写了一个辅助方法 calculateDotProduct 来计算两个向量的点积。
    3. 点积的计算是通过遍历两个向量的坐标并对应相乘后累加得到的。
    案例总结：
    • 这个示例演示了如何使用Java来计算两个向量的点积（内积）。
    • 辅助方法 calculateDotProduct 接受两个整数数组，先检查它们的长度是否一致，然后计算点积。
    • 数组是一种有助于进行向量和矩阵运算的工具，它们常用于线性代数和数学领域的计算。
    • 通过这个练习，读者可以学习如何使用数组来进行向量运算，以及如何编写和调用自定义的辅助方法。
    5. 数组排列算法

    练习8： 使用冒泡排序或选择排序对一个整数数组进行升序排列，并打印排序后的数组。
    以下是使用Java回答 “数组排列算法” 模块中的练习8的示例，采用冒泡排序算法，并包括解释和总结：

    使用冒泡排序对整数数组进行升序排列
    1. public class Main {
    2.     public static void main(String[] args) {
    3.         int[] numbers = {5, 2, 9, 1, 5, 6};
    4.  
    5.         System.out.println("排序前的数组：");
    6.         printArray(numbers);
    7.  
    8.         // 使用冒泡排序算法对数组进行升序排列
    9.         bubbleSort(numbers);
    10.  
    11.         System.out.println("排序后的数组：");
    12.         printArray(numbers);
    13.     }
    14.  
    15.     // 冒泡排序算法
    16.     public static void bubbleSort(int[] arr) {
    17.         int n = arr.length;
    18.         boolean swapped;
    19.  
    20.         for (int i = 0; i < n - 1; i++) {
    21.             swapped = false;
    22.  
    23.             for (int j = 0; j < n - i - 1; j++) {
    24.                 if (arr[j] > arr[j + 1]) {
    25.                     // 交换arr[j]和arr[j+1]的位置
    26.                     int temp = arr[j];
    27.                     arr[j] = arr[j + 1];
    28.                     arr[j + 1] = temp;
    29.                     swapped = true;
    30.                 }
    31.             }
    32.  
    33.             // 如果内循环没有发生交换，表示数组已排序完成，可以提前退出
    34.             if (!swapped) {
    35.                 break;
    36.             }
    37.         }
    38.     }
    39.  
    40.     // 打印数组
    41.     public static void printArray(int[] arr) {
    42.         for (int num : arr) {
    43.             System.out.print(num + " ");
    44.         }
    45.         System.out.println();
    46.     }
    47. }
    案例分析：
    1. 在这个练习中，我们首先创建了一个整数数组 numbers，包含一些未排序的整数。
    2. 使用冒泡排序算法来对数组进行升序排列，排序后的数组将覆盖原始数组。
    3. 冒泡排序算法的核心思想是依次比较相邻的元素并交换它们，将较大的元素逐步向右移动。
    4. 我们使用 printArray 方法来打印排序前和排序后的数组。
    案例总结：
    • 这个示例演示了如何使用Java实现冒泡排序算法来对整数数组进行升序排列。
    • 冒泡排序是一种简单但不高效的排序算法，它依次比较相邻元素并交换它们，直到数组完全有序。
    • 冒泡排序适用于小型数据集，但在大型数据集上性能较差。
    • 通过这个练习，读者可以学习排序算法的基本原理和实现方式，以及如何应用它们来排序数组。

    练习9： 编写一个程序，生成一个包含10个随机整数的数组，并使用快速排序算法对其进行排序。
    以下是使用Java回答 “数组排列算法” 模块中的练习9的示例，采用快速排序算法，并包括解释和总结：

    使用快速排序对包含10个随机整数的数组进行排序
    1. import java.util.Random;
    2.  
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         int[] numbers = generateRandomArray(10);
    6.  
    7.         System.out.println("排序前的数组：");
    8.         printArray(numbers);
    9.  
    10.         // 使用快速排序算法对数组进行升序排列
    11.         quickSort(numbers, 0, numbers.length - 1);
    12.  
    13.         System.out.println("排序后的数组：");
    14.         printArray(numbers);
    15.     }
    16.  
    17.     // 快速排序算法
    18.     public static void quickSort(int[] arr, int low, int high) {
    19.         if (low < high) {
    20.             int pivotIndex = partition(arr, low, high);
    21.  
    22.             // 递归排序左半部分和右半部分
    23.             quickSort(arr, low, pivotIndex - 1);
    24.             quickSort(arr, pivotIndex + 1, high);
    25.         }
    26.     }
    27.  
    28.     // 快速排序的分区函数
    29.     public static int partition(int[] arr, int low, int high) {
    30.         int pivot = arr[high];
    31.         int i = low - 1;
    32.  
    33.         for (int j = low; j < high; j++) {
    34.             if (arr[j] < pivot) {
    35.                 i++;
    36.                 // 交换arr[i]和arr[j]的位置
    37.                 int temp = arr[i];
    38.                 arr[i] = arr[j];
    39.                 arr[j] = temp;
    40.             }
    41.         }
    42.  
    43.         // 交换arr[i+1]和arr[high]的位置，将pivot放到正确的位置
    44.         int temp = arr[i + 1];
    45.         arr[i + 1] = arr[high];
    46.         arr[high] = temp;
    47.  
    48.         return i + 1;
    49.     }
    50.  
    51.     // 生成包含n个随机整数的数组
    52.     public static int[] generateRandomArray(int n) {
    53.         int[] arr = new int[n];
    54.         Random random = new Random();
    55.  
    56.         for (int i = 0; i < n; i++) {
    57.             arr[i] = random.nextInt(100); // 生成0到99之间的随机整数
    58.         }
    59.  
    60.         return arr;
    61.     }
    62.  
    63.     // 打印数组
    64.     public static void printArray(int[] arr) {
    65.         for (int num : arr) {
    66.             System.out.print(num + " ");
    67.         }
    68.         System.out.println();
    69.     }
    70. }
    案例分析：
    1. 在这个练习中，我们首先生成包含10个随机整数的数组 numbers。
    2. 使用快速排序算法 quickSort 对数组进行升序排列。
    3. 快速排序算法的核心思想是选择一个基准元素（这里选择最后一个元素），将数组分为两部分，左边部分小于基准元素，右边部分大于基准元素，然后递归排序左右两部分。
    4. 我们使用 generateRandomArray 方法来生成随机数组，并使用 printArray 方法来打印排序前和排序后的数组。
    案例总结：
    • 这个示例演示了如何使用Java实现快速排序算法来对包含随机整数的数组进行升序排列。
    • 快速排序是一种高效的排序算法，平均时间复杂度为 O(nlogn)。
    • 快速排序的关键是分区（partition）过程，它将数组分为两部分并递归排序，直到整个数组有序。
    • 通过这个练习，读者可以学习排序算法的高效性和递归算法的应用。
    6. 实践与练习

    练习10： 创建一个简单的任务管理程序，使用数组来存储任务的描述和状态（未完成/已完成），并提供选项来添加、查看和标记任务的状态。

    1. import java.util.Scanner;
    2.  
    3. public class TaskManager {
    4.     private static final int MAX_TASKS = 100; // 最大任务数量
    5.     private String[] tasks; // 存储任务的描述
    6.     private boolean[] taskStatus; // 存储任务的状态，true表示已完成，false表示未完成
    7.     private int taskCount; // 任务数量
    8.  
    9.     public TaskManager() {
    10.         tasks = new String[MAX_TASKS];
    11.         taskStatus = new boolean[MAX_TASKS];
    12.         taskCount = 0;
    13.     }
    14.  
    15.     // 添加新任务
    16.     public void addTask(String description) {
    17.         if (taskCount < MAX_TASKS) {
    18.             tasks[taskCount] = description;
    19.             taskStatus[taskCount] = false; // 默认设置为未完成
    20.             taskCount++;
    21.             System.out.println("任务已添加！");
    22.         } else {
    23.             System.out.println("任务列表已满，无法添加新任务。");
    24.         }
    25.     }
    26.  
    27.     // 查看任务列表
    28.     public void viewTasks() {
    29.         if (taskCount == 0) {
    30.             System.out.println("任务列表为空。");
    31.         } else {
    32.             System.out.println("任务列表：");
    33.             for (int i = 0; i < taskCount; i++) {
    34.                 String status = taskStatus[i] ? "[已完成]" : "[未完成]";
    35.                 System.out.println(status + " " + (i + 1) + ". " + tasks[i]);
    36.             }
    37.         }
    38.     }
    39.  
    40.     // 标记任务状态
    41.     public void markTaskCompleted(int index) {
    42.         if (index >= 1 && index <= taskCount) {
    43.             taskStatus[index - 1] = true;
    44.             System.out.println("任务已标记为已完成。");
    45.         } else {
    46.             System.out.println("无效的任务索引。");
    47.         }
    48.     }
    49.  
    50.     public static void main(String[] args) {
    51.         TaskManager taskManager = new TaskManager();
    52.         Scanner scanner = new Scanner(System.in);
    53.  
    54.         while (true) {
    55.             System.out.println("任务管理程序选项：");
    56.             System.out.println("1. 添加新任务");
    57.             System.out.println("2. 查看任务列表");
    58.             System.out.println("3. 标记任务为已完成");
    59.             System.out.println("4. 退出程序");
    60.             System.out.print("请选择操作（1/2/3/4）：");
    61.  
    62.             int choice = scanner.nextInt();
    63.             scanner.nextLine(); // 消耗换行符
    64.  
    65.             switch (choice) {
    66.                 case 1:
    67.                     System.out.print("请输入任务描述：");
    68.                     String description = scanner.nextLine();
    69.                     taskManager.addTask(description);
    70.                     break;
    71.                 case 2:
    72.                     taskManager.viewTasks();
    73.                     break;
    74.                 case 3:
    75.                     System.out.print("请输入要标记为已完成的任务索引：");
    76.                     int index = scanner.nextInt();
    77.                     taskManager.markTaskCompleted(index);
    78.                     break;
    79.                 case 4:
    80.                     System.out.println("程序已退出。");
    81.                     scanner.close();
    82.                     System.exit(0);
    83.                 default:
    84.                     System.out.println("无效的选项，请重新选择。");
    85.                     break;
    86.             }
    87.         }
    88.     }
    89. }
    案例分析：
    1. 这个示例创建了一个名为 TaskManager 的任务管理程序类，使用数组来存储任务的描述和状态（未完成/已完成）。
    2. 用户可以通过选项来添加新任务、查看任务列表和标记任务状态。
    3. 主程序部分使用一个无限循环，用户可以根据提示选择不同的操作。
    4. 使用 Scanner 类来接受用户的输入。
    案例总结：
    • 这个示例演示了如何使用Java创建一个简单的任务管理程序，它使用数组来存储任务信息并提供基本的操作选项。
    • 数组在这个程序中用于存储任务描述和状态，可以轻松地扩展功能以满足更复杂的需求。
    • 通过这个练习，读者可以学习如何使用数组和基本的控制结构来创建一个小型的命令行程序，这有助于理解数组在实际应用中的用途。
  • 相关阅读:
    Paper Reading:《Consistent-Teacher: 减少半监督目标检测中不一致的伪目标》
    牛客多校4 N Particle Arts
    Nginx - 反向代理与负载均衡
    基于偏二叉树SVM多分类算法的应用层DDoS检测方法
    Apollo学习（超详细）
    【WiFi】WiFi信道（2.4G、5G及5G DFS)及国家码和电话代码和时区对应表
    【asp.net core】自定义模型绑定及其验证
    【Web】关于FastJson反序列化开始前的那些前置知识
    树莓派4b+mcp2515实现CAN总线通讯和系统编程(一.配置树莓派CAN总线接口)
    【python】我用python写了一个可以批量查询文章质量分的小项目（纯python、flask+html、打包成exe文件）
  • 原文地址：https://blog.csdn.net/m0_53918860/article/details/132792457