练习一维数组

练习一

/**
 * 案例："破解"房东电话
 * 
 * 升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。
 * 所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。
 * 
 */

代码：

public class ArrayExer {
   public static void main(String[] args) {
      int[] arr = new int[] { 8, 2, 1, 0, 3 };
      int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };
      
      String tel = "";
      
      for (int i = 0; i < index.length; i++) {
         int value = index[i];
         tel += arr[value];
      }
      System.out.println("联系方式：" + tel); //
      
   }
}

解释

首先，让我们看看数组 `arr` 和 `index` 的内容：

```java
int[] arr = new int[] { 8, 2, 1, 0, 3 };
int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };
```

这里有两个数组：

- `arr` 数组包含了整数 `{ 8, 2, 1, 0, 3 }`。
- `index` 数组包含了整数 `{ 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 }`。

现在，我们来解释代码中的循环部分：

```java
for (int i = 0; i < index.length; i++) {
    int value = index[i];
    tel += arr[value];
}
```

这个循环会迭代 `index` 数组的每一个元素。在每次迭代中，我们取出 `index` 数组当前位置的值，然后将其作为索引应用到 `arr` 数组中，取得相应位置的值，最后将这个值追加到字符串 `tel` 上。

举个例子：

第一次迭代时，`index[0]` 的值是 `2`，因此我们取 `arr[2]`，即 `1`，将 `1` 追加到 `tel` 上。
第二次迭代时，`index[1]` 的值是 `0`，因此我们取 `arr[0]`，即 `8`，将 `8` 追加到 `tel` 上。
以此类推，直到迭代完整个 `index` 数组。

最后，打印输出结果：

```java
System.out.println("联系方式：" + tel);
```

这行代码会输出拼接好的联系方式字符串 `tel`，这个字符串就是 `arr` 数组中根据 `index` 数组指示的顺序拼接的。

所以最终输出的联系方式是 `18203`。

这段代码使用了一个循环，将一个数组中指定索引位置的值拼接成一个字符串。

```java
public class ArrayExer {
    public static void main(String[] args) {
        // 定义并初始化两个整型数组
        int[] arr = new int[] { 8, 2, 1, 0, 3 };
        int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };
        
        // 定义一个空字符串
        String tel = "";
        
        // 遍历 index 数组
        for (int i = 0; i < index.length; i++) {
            // 获取当前索引在 index 数组中的值
            int value = index[i];
            // 将 arr 数组中相应索引位置的值拼接到 tel 字符串中
            tel += arr[value];
        }
        // 打印输出拼接好的字符串
        System.out.println("联系方式：" + tel);
    }
}
```

下面是对代码的逐行解释：

1. `public class ArrayExer {`: 声明一个名为 `ArrayExer` 的公共类。
2. `public static void main(String[] args) {`: 声明 `main` 方法，是 Java 程序的入口点。
3. `int[] arr = new int[] { 8, 2, 1, 0, 3 };`: 创建一个名为 `arr` 的整型数组，并初始化为 `{ 8, 2, 1, 0, 3 }`。
4. `int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };`: 创建一个名为 `index` 的整型数组，并初始化为 `{ 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 }`。
5. `String tel = "";`: 声明一个名为 `tel` 的空字符串，用于存储拼接后的联系方式。
6. `for (int i = 0; i < index.length; i++) {`: 使用 `for` 循环遍历 `index` 数组。
7. `int value = index[i];`: 获取当前循环迭代中 `index` 数组的值。
8. `tel += arr[value];`: 将 `arr` 数组中索引为 `value` 的元素的值拼接到 `tel` 字符串后面。
9. `System.out.println("联系方式：" + tel);`: 打印输出拼接好的字符串，即联系方式。

总体而言，这段代码的作用是从 `arr` 数组中按照 `index` 数组指定的顺序提取元素，然后将这些元素拼接成一个字符串，以形成一个联系方式。

练习二

案例：输出英文星期几

用一个数组，保存星期一到星期天的7个英语单词，从键盘输入1-7，显示对应的单词
{"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"}

代码

public class ArrayExer02 {
    public static void main(String[] args) {
        //定义包含7个单词的数组
        String[] weeks = {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};

        //从键盘获取指定的数值，使用Scanner
        Scanner scan  = new Scanner(System.in);
        System.out.println("请输入数值（1-7）：");
        int day = scan.nextInt();

        //针对获取的数据进行判断即可
        if(day < 1 || day > 7){
            System.out.println("你输入的数据有误。");
        }else{
            System.out.println(weeks[day - 1]);
        }

        scan.close();
    }
}
 

解释：

这段代码的功能是根据用户输入的数字（代表星期几），输出相应的英文星期名称。

让我们逐行解释：

1. `String[] weeks = {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};`：定义了一个包含了星期一到星期天的英文单词的字符串数组。

2. `Scanner scan  = new Scanner(System.in);`：创建了一个 `Scanner` 对象，用于从键盘输入数据。

3. `System.out.println("请输入数值（1-7）：");`：输出提示信息，要求用户输入一个数字（代表星期几）。

4. `int day = scan.nextInt();`：使用 `Scanner` 对象的 `nextInt()` 方法获取用户输入的整数值，表示星期几。

5. `if(day < 1 || day > 7){ System.out.println("你输入的数据有误。"); }`：检查用户输入的数字是否在范围 `[1, 7]` 内，如果不在这个范围内，则输出错误提示信息。

6. `else{ System.out.println(weeks[day - 1]); }`：如果用户输入的数字在合法范围内，则根据输入的数字，从 `weeks` 数组中获取相应的英文星期名称，并输出。

7. `scan.close();`：关闭 `Scanner` 对象，释放资源。

这段代码的核心是通过一个数组 `weeks` 存储了星期的英文名称，然后根据用户输入的数字来索引相应的名称，并将其输出。

第6点 为什么是weeks[day - 1]

在Java中，数组的索引是从0开始的，而星期的编号通常是从1开始的（星期一是1，星期二是2，依此类推）。因此，当用户输入1代表星期一时，我们需要从数组中获取索引为0的元素（即第一个元素，对应星期一）。同样地，当用户输入2代表星期二时，我们需要获取索引为1的元素（即第二个元素，对应星期二），以此类推。

所以在代码中，我们需要将用户输入的数字（代表星期几）减去1，以获得正确的数组索引位置，然后从数组中取出相应的英文星期名称。因此，使用 `weeks[day - 1]` 来获取正确的星期名称。

当我们定义数组时，它的索引是从0开始的。例如，对于一个长度为7的数组，索引范围是0到6，而不是1到7。在这个例子中，我们的数组 `weeks` 包含了7个元素，分别对应着星期一到星期天。

当用户输入一个数字，表示星期几时，我们需要将这个数字转换成数组的索引。假设用户输入的是1，代表星期一。但是在数组中，星期一对应的索引是0，星期二对应的索引是1，以此类推。因此，我们需要将用户输入的数字减去1，以得到正确的索引位置。

举个例子：

- 如果用户输入1，代表星期一。我们需要从数组中获取索引为0的元素，即 `weeks[0]`，对应的是 "Monday"。
- 如果用户输入2，代表星期二。我们需要从数组中获取索引为1的元素，即 `weeks[1]`，对应的是 "Tuesday"。

这样，通过将用户输入的数字减去1，我们可以得到正确的数组索引位置，从而获取对应的星期名称。这就是为什么在代码中使用 `weeks[day - 1]` 来获取正确的星期名称的原因。

练习三

拓展：一年12个月的存储

用一个数组，保存12个月的英语单词，从键盘输入1-12，显示对应的单词。
{"January","February","March","April","May","June","July","August","September","October","November","December"}

代码：

package com.atguigu1.one.exer2;

import java.util.Scanner;

/**
 * ClassName: ArrayExer03
 * Package: com.atguigu1.one.exer2
 * Description:  案例
 * 拓展：一年12个月的存储
 *
 * 用一个数组，保存12个月的英语单词，从键盘输入1-12，显示对应的单词。
 * {"January","February","March","April","May","June","July","August","September","October","November","December"}
 * @Author 小白
 * @Create 2024/3/27 9:19
 * @Version 1.0
 */
public class ArrayExer03 {

    public static void main(String[] args) {
        // //定义包含12月份的数组
      String[]  months = {"January","February","March","April","May","June","July","August","September","October","November","December"};
      //从键盘获取指定的数值，使用Scanner
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入（1-12）：");
        int day = scan.nextInt();
        //针对获取的数据进行判断即可
        if(day <1 ||  day >12){
            System.out.println("你输入的数据有误");
        }else {
            System.out.println(months[day - 1]);
        }


        scan.close();


    }
}

题目：一年12个月的存储

编写一个程序，使用一个数组来保存12个月的英语单词。程序应该从键盘输入一个数字（1到12之间的整数），然后显示对应月份的英语单词。

解析：
1. 首先，我们需要创建一个包含12个月份英语单词的数组。
2. 接着，程序需要从用户那里获取输入的数字。
3. 然后，程序将输入的数字作为索引，从数组中获取对应的月份英语单词。
4. 最后，程序将该单词显示给用户。

下面是一个Java语言的示例代码：

```java
import java.util.Scanner;

public class MonthWords {
    public static void main(String[] args) {
        // 创建包含12个月份英语单词的数组
        String[] months = {"January", "February", "March", "April", "May", "June",
                           "July", "August", "September", "October", "November", "December"};
        
        // 创建Scanner对象以从键盘获取输入
        Scanner scanner = new Scanner(System.in);
        
        // 提示用户输入数字
        System.out.print("请输入1-12之间的数字：");
        
        // 读取用户输入的数字
        int inputNumber = scanner.nextInt();
        
        // 确保输入的数字在1到12之间
        if (inputNumber >= 1 && inputNumber <= 12) {
            // 使用输入的数字作为索引获取对应的月份英语单词
            String monthWord = months[inputNumber - 1]; // 数组索引从0开始，所以需要减去1
            // 显示对应的月份英语单词
            System.out.println("对应的月份是：" + monthWord);
        } else {
            // 如果输入的数字不在1到12之间，显示错误信息
            System.out.println("输入的数字无效，请输入1-12之间的数字。");
        }
        
        // 关闭Scanner
        scanner.close();
    }
}
```

这段代码首先创建了一个包含12个月份英语单词的数组。然后，它提示用户输入一个数字，并读取用户的输入。接下来，它检查输入的数字是否在1到12之间。如果是，它使用该数字作为索引从数组中获取对应的月份英语单词，并将其显示给用户。否则，它显示错误消息。最后，它关闭了Scanner对象。

练习四

案例：学生考试等级划分

从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
    成绩>=最高分-10    等级为’A’
    成绩>=最高分-20    等级为’B’
    成绩>=最高分-30    等级为’C’
    其余              等级为’D’

提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

代码

public class ArrayExer03 {
    public static void main(String[] args) {
        //1. 从键盘输入学生的人数，根据人数，创建数组(动态初始化)
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入学生人数：");
        int count = scan.nextInt();

        int[] scores = new int[count];

        //2. 根据提示，依次输入学生成绩，并将成绩保存在数组元素中
        System.out.println("请输入" + count + "个成绩");
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scan.nextInt();
        }

        //3. 获取学生成绩的最大值
        int maxScore = scores[0];
        for (int i = 1; i < scores.length; i++) {
            if (maxScore < scores[i]) {
                maxScore = scores[i];
            }
        }

        System.out.println("最高分是：" + maxScore);

        //4. 遍历数组元素，根据学生成绩与最高分的差值，得到每个学生的等级，并输出成绩和等级
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] >= maxScore - 10) {
                System.out.println("student " + i + " score is " + scores[i] +
                        " grade is A");
            } else if (scores[i] >= maxScore - 20) {
                System.out.println("student " + i + " score is " + scores[i] +
                        " grade is B");
            } else if (scores[i] >= maxScore - 30) {
                System.out.println("student " + i + " score is " + scores[i] +
                        " grade is C");
            } else {
                System.out.println("student " + i + " score is " + scores[i] +
                        " grade is D");
            }
        }

        scan.close();

    }
}

解释：

这段代码的功能是从键盘读入学生的考试成绩，然后根据最高分对每个学生的成绩进行等级划分，并输出成绩和等级。

让我们逐行解释代码：

1. `Scanner scan = new Scanner(System.in);`: 创建了一个 `Scanner` 对象，用于从键盘输入数据。

2. `System.out.print("请输入学生人数：");`: 输出提示信息，要求用户输入学生的人数。

3. `int count = scan.nextInt();`: 使用 `Scanner` 对象的 `nextInt()` 方法获取用户输入的整数值，即学生的人数。

4. `int[] scores = new int[count];`: 根据输入的学生人数创建了一个整型数组 `scores`，用于存储学生成绩。

5. `System.out.println("请输入" + count + "个成绩");`: 输出提示信息，要求用户依次输入每个学生的成绩。

6. `for (int i = 0; i < scores.length; i++) { scores[i] = scan.nextInt(); }`: 使用 `for` 循环遍历数组 `scores`，在每次迭代中，从键盘输入一个学生成绩，并将其存储到数组中。

7. 获取学生成绩的最大值：
   - 初始化一个变量 `maxScore` 为数组第一个元素 `scores[0]`。
   - 遍历数组中的每个元素，比较当前元素与 `maxScore` 的大小，如果当前元素大于 `maxScore`，则更新 `maxScore` 的值。

8. 输出最高分：`System.out.println("最高分是：" + maxScore);`

9. 遍历数组 `scores`，根据学生成绩与最高分的差值，确定每个学生的等级，并输出成绩和等级。
   - 如果学生成绩大于等于最高分减去10，则等级为'A'。
   - 如果学生成绩大于等于最高分减去20，则等级为'B'。
   - 如果学生成绩大于等于最高分减去30，则等级为'C'。
   - 否则，等级为'D'。

10. `scan.close();`: 关闭 `Scanner` 对象，释放资源。

这段代码实现了一个简单的学生考试等级划分系统，根据输入的学生成绩，确定其等级并输出。

当用户运行这个程序时，它首先会要求用户输入学生的人数。用户会在命令行界面中输入一个整数，表示学生的数量。然后，根据这个数字创建一个整型数组，用于存储学生的成绩。

接下来，程序会提示用户输入每个学生的成绩。程序会逐个提示用户输入每个学生的成绩，并将这些成绩存储到数组中。

一旦所有成绩都输入完毕，程序会遍历数组，找出最高的成绩。这样我们就能知道最高分是多少，用于后续的等级划分。

举个例子，假设有5个学生，分别输入的成绩是85、90、78、95和88。程序会先找出这些成绩中的最高分，即95。然后，它会根据以下规则为每个学生分配一个等级：

- 如果学生的成绩大于等于最高分减去10（即85或更高），则他们的等级为'A'。
- 如果学生的成绩大于等于最高分减去20（即75或更高），但小于最高分减去10（即85），则他们的等级为'B'。
- 如果学生的成绩大于等于最高分减去30（即65或更高），但小于最高分减去20（即75），则他们的等级为'C'。
- 如果学生的成绩低于最高分减去30（即65），则他们的等级为'D'。

然后，程序会输出每个学生的成绩和等级。在这个例子中，输出可能是类似这样的内容：

```
student 0 score is 85 grade is A
student 1 score is 90 grade is A
student 2 score is 78 grade is B
student 3 score is 95 grade is A
student 4 score is 88 grade is A
```

最后，程序会关闭用于输入的 `Scanner` 对象，释放资源，并结束运行。

逐行解释代码：

```java
package com.atguigu1.one.exer3;

import java.util.Scanner;

/**
 * ClassName: ArrayExer03
 * Description:
 * 案例：学生考试等级划分
 * <p>
 * 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
 * 成绩>=最高分-10    等级为’A’
 * 成绩>=最高分-20    等级为’B’
 * 成绩>=最高分-30    等级为’C’
 * 其余              等级为’D’
 *
 * @Author 尚硅谷-宋红康
 * @Create 10:42
 * @Version 1.0
 */
public class ArrayExer03 {
    public static void main(String[] args) {
        //1. 从键盘输入学生的人数，根据人数，创建数组(动态初始化)
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入学生人数：");
        int count = scan.nextInt();

        int[] scores = new int[count];

        //2. 根据提示，依次输入学生成绩，并将成绩保存在数组元素中
        System.out.println("请输入" + count + "个成绩");
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scan.nextInt();
        }

        //3. 获取学生成绩的最大值
        int maxScore = scores[0];
        for (int i = 1; i < scores.length; i++) {
            if (maxScore < scores[i]) {
                maxScore = scores[i];
            }
        }

        System.out.println("最高分是：" + maxScore);

        //4. 遍历数组元素，根据学生成绩与最高分的差值，得到每个学生的等级，并输出成绩和等级
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] >= maxScore - 10) {
                System.out.println("student " + i + " score is " + scores[i] +
                        " grade is A");
            } else if (scores[i] >= maxScore - 20) {
                System.out.println("student " + i + " score is " + scores[i] +
                        " grade is B");
            } else if (scores[i] >= maxScore - 30) {
                System.out.println("student " + i + " score is " + scores[i] +
                        " grade is C");
            } else {
                System.out.println("student " + i + " score is " + scores[i] +
                        " grade is D");
            }
        }

        scan.close();

    }
}
```

现在让我解释每一行代码：

1. `package com.atguigu1.one.exer3;`: 声明了这个类的包名，这里的包名表明这个类属于 `com.atguigu1.one.exer3` 包。

2. `import java.util.Scanner;`: 导入 `java.util.Scanner` 类，用于从控制台读取用户的输入。

3. 这一段是注释，提供了关于这个类的描述，以及程序的功能和规则。

4. `public class ArrayExer03 {`: 声明了一个公共类 `ArrayExer03`，类名为 `ArrayExer03`。

5. `public static void main(String[] args) {`: 声明了 `main` 方法，是程序的入口点。

6. 创建 `Scanner` 对象，用于从键盘读取输入。

7. 输出提示信息，要求用户输入学生人数。

8. 从键盘读取用户输入的整数值，表示学生的数量，存储在变量 `count` 中。

9. 根据输入的学生人数创建一个整型数组 `scores`，用于存储学生成绩。

10. 输出提示信息，要求用户输入每个学生的成绩。

11. 使用 `for` 循环遍历数组 `scores`，在每次迭代中，从键盘读取一个学生的成绩，并将其存储到数组中。

12. 初始化一个变量 `maxScore` 为数组第一个元素 `scores[0]`。

13. 使用 `for` 循环遍历数组 `scores`，在每次迭代中，比较当前元素与 `maxScore` 的大小，如果当前元素大于 `maxScore`，则更新 `maxScore` 的值。

14. 输出最高分。

15. 使用 `for` 循环遍历数组 `scores`，在每次迭代中，根据学生成绩与最高分的差值确定每个学生的等级，并输出成绩和等级。

16. 关闭 `Scanner` 对象，释放资源。

解释一下这个int maxScore = scores[0];

当代码执行到 `int maxScore = scores[0];` 这一行时，它的目的是初始化一个变量 `maxScore`，将其值设为数组 `scores` 的第一个元素的值。

在这个程序中，我们要找出学生中的最高分，因此我们需要一个变量来跟踪当前已知的最高分。开始时，我们选择将 `maxScore` 初始化为数组的第一个元素 `scores[0]`，因为我们还没有找到更高的分数，所以当前的最高分就是第一个学生的成绩。

随后，我们会用 `for` 循环遍历数组 `scores`，逐个比较每个学生的成绩与当前的 `maxScore`。如果某个学生的成绩比当前的 `maxScore` 高，我们就会更新 `maxScore` 的值为这个更高的成绩。通过这种方式，我们可以找出整个数组中的最高分。

总之，`int maxScore = scores[0];` 这行代码的作用是初始化一个变量 `maxScore`，将其值设为数组的第一个元素的值，以便在后续的代码中用来跟踪最高分。

 优化;

代码

public class ArrayExer03_1 {
    public static void main(String[] args) {
        //1. 从键盘输入学生的人数，根据人数，创建数组(动态初始化)
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入学生人数：");
        int count = scan.nextInt();

        int[] scores = new int[count];

        //2. 根据提示，依次输入学生成绩，并将成绩保存在数组元素中
        int maxScore = scores[0];
        System.out.println("请输入" + count + "个成绩");
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scan.nextInt();
            //3. 获取学生成绩的最大值
            if (maxScore < scores[i]) {
                maxScore = scores[i];
            }
        }
        System.out.println("最高分是：" + maxScore);

        //4. 遍历数组元素，根据学生成绩与最高分的差值，得到每个学生的等级，并输出成绩和等级
        char grade;
        for (int i = 0; i < scores.length; i++) {

            if (scores[i] >= maxScore - 10) {
                grade = 'A';
            } else if (scores[i] >= maxScore - 20) {
                grade = 'B';
            } else if (scores[i] >= maxScore - 30) {
                grade = 'C';
            } else {
                grade = 'D';
            }

            System.out.println("student " + i + " score is " + scores[i] +
                    " grade is " + grade);
        }

        scan.close();

    }
}

这段代码的功能与前面提供的相似，它仍然是根据学生的考试成绩划分等级，并输出每个学生的成绩和等级。

让我们逐行解释这段代码：

```java
package com.atguigu1.one.exer3;

import java.util.Scanner;

/**
 * ClassName: ArrayExer03_1
 * Description:
 *
 * @Author 尚硅谷-宋红康
 * @Create 10:54
 * @Version 1.0
 */
public class ArrayExer03_1 {
    public static void main(String[] args) {
```

1. 这段代码首先声明了一个包名，并导入了 `java.util.Scanner` 类，以便从控制台读取用户的输入。

```java
        //1. 从键盘输入学生的人数，根据人数，创建数组(动态初始化)
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入学生人数：");
        int count = scan.nextInt();

        int[] scores = new int[count];
```

2. 这部分代码与前一个示例类似，首先要求用户输入学生的人数，然后根据人数创建一个整型数组 `scores`。

```java
        //2. 根据提示，依次输入学生成绩，并将成绩保存在数组元素中
        int maxScore = scores[0];
        System.out.println("请输入" + count + "个成绩");
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scan.nextInt();
            //3. 获取学生成绩的最大值
            if (maxScore < scores[i]) {
                maxScore = scores[i];
            }
        }
        System.out.println("最高分是：" + maxScore);
```

3. 这部分代码与前一个示例有所不同。在输入成绩的同时，我们也在循环中检查每个学生的成绩，并更新 `maxScore` 变量以保存最高分。

```java
        //4. 遍历数组元素，根据学生成绩与最高分的差值，得到每个学生的等级，并输出成绩和等级
        char grade;
        for (int i = 0; i < scores.length; i++) {

            if (scores[i] >= maxScore - 10) {
                grade = 'A';
            } else if (scores[i] >= maxScore - 20) {
                grade = 'B';
            } else if (scores[i] >= maxScore - 30) {
                grade = 'C';
            } else {
                grade = 'D';
            }

            System.out.println("student " + i + " score is " + scores[i] +
                    " grade is " + grade);
        }
```

4. 最后，我们遍历数组，并根据每个学生的成绩与最高分的差值确定其等级。然后，我们输出每个学生的成绩和等级。

```java
        scan.close();
    }
}
```

5. 最后关闭了 `Scanner` 对象，释放资源。

这段代码的主要不同之处在于在输入成绩的同时就计算了最高分，并在遍历数组时直接根据最高分来确定学生的等级。

在这个代码示例中，主要的优化部分是在输入学生成绩的同时，就计算了最高分，并在遍历数组时直接根据最高分来确定学生的等级。

让我们详细解释这个优化：

1. **同时计算最高分：**
   - 在循环中，每次读取一个学生成绩时，我们会立即检查该成绩是否高于当前已知的最高分（`maxScore`）。如果是，就更新 `maxScore` 的值为这个更高的成绩。
   - 这样，我们就在输入成绩的同时，就计算了最高分，而不需要再额外遍历一次数组来找出最高分。这样做可以减少代码的复杂度和运行时间。

2. **根据最高分确定等级：**
   - 在遍历数组时，我们使用 `maxScore` 的值直接进行等级划分，而不是根据最高分来计算等级划分的阈值（例如最高分减去10、20、30等）。
   - 这种方法更直观，也更简洁，因为我们不需要再次计算阈值，只需要根据最高分即可确定学生的等级。

通过这些优化，我们可以在输入成绩的同时，即时地计算最高分，并且在遍历数组时直接根据最高分确定每个学生的等级，从而使代码更加简洁、高效。

解释 `char grade;` 的作用。

好的，让我们结合完整的例子来解释 `char grade;` 的作用。

在这个例子中，我们有一个程序，它的功能是根据输入的学生成绩计算等级，并输出最高分和每个学生的成绩与等级。让我们一步步来解释：

1. 在程序的开头，我们声明了一个类 `ArrayExer03_1`，然后在 `main` 方法中开始程序的执行。

2. 第一步是要求用户输入学生的人数，并将人数保存在变量 `count` 中。然后我们根据人数创建一个大小为 `count` 的整型数组 `scores`，用于存储学生成绩。

3. 接下来，我们提示用户依次输入学生成绩，并将输入的成绩存储在数组 `scores` 中。在此过程中，我们还记录了最高成绩 `maxScore`，并将其初始化为第一个学生的成绩。

4. 随后，我们遍历数组 `scores`，对每个学生的成绩进行判断，然后分配等级，并输出学生的成绩和等级。在这一步中，我们需要一个变量来存储每个学生的等级。这就是 `char grade;` 的作用。

   在每次循环开始时，我们为当前学生声明一个 `grade` 变量。在循环的每次迭代中，我们根据学生的成绩计算其等级，并将等级存储在 `grade` 变量中。然后我们使用这个 `grade` 变量来输出学生的成绩和等级。因为我们在循环内部声明了 `grade` 变量，所以每个学生都有自己独立的 `grade` 变量来存储其等级。

5. 最后，我们关闭了 `Scanner` 对象，释放资源。

所以，`char grade;` 的作用是声明一个字符型变量 `grade`，用于存储每个学生的成绩等级。在每次循环迭代中，`grade` 变量都会被重新赋值，并在输出学生成绩和等级时使用。