java学习day2--数组、方法（知识点总结，习题逐语句分析，附带全套源代码）--万字超详细解析！！！

@VON

发布于 2025-12-17 10:07:47

1050

一、前言

java已经第二天了，今天学习了数组和方法，基础篇差不多也该结束了，今天的习题可能会有些难度，但是相信对于读者们来说问题不大。这篇文章写到了凌晨12点。因为今天的知识点不像昨天那样那么基础，在加上写文章。明天要多留出一点时间来学习java了。争取一周拿下它！！！

习题都是逐语句进行讲解的，每一个习题都是重头到尾进行分析的，希望读者们可以认真反复观看，也可以用其他语言进行尝试。

习题参考：黑马程序员

二、数组、方法知识点总结

在Java中，数组是一种用来存储多个相同类型数据元素的容器。

2.1 数组

2.1.1 数组的声明和初始化

声明数组时，需要指定数组的类型和名称，如 int[] arr; 表示声明了一个整型数组。
初始化数组可以使用静态初始化或动态初始化：

int[] arr1 = {1, 2, 3, 4, 5}; // 静态初始化
int[] arr2 = new int[5]; // 动态初始化，创建长度为5的整型数组

2.1.2 访问数组元素

数组元素的访问通过索引（下标）来进行，索引从0开始。
例如，访问数组中第一个元素：int firstElement = arr1[0];

2.1.3 数组的长度

数组的长度是固定的，一旦确定，就不能改变。
可以通过数组的 length 属性获取数组的长度，例如 int length = arr1.length;

2.1.4 多维数组

Java支持多维数组，例如二维数组、三维数组等。
二维数组的声明和初始化：

int[][] matrix = new int[3][4]; // 3行4列的二维数组

2.1.5 数组的遍历

使用循环结构（如 for 循环或 foreach 循环）可以遍历数组元素。

2.1.6 数组的复制

使用 System.arraycopy() 方法或者 Arrays.copyOf() 方法可以复制数组。

2.1.7 数组的排序和搜索

使用 Arrays.sort() 方法可以对数组进行排序。
使用 Arrays.binarySearch() 方法可以在已排序的数组中进行二分查找。

2.1.8 数组的注意事项

数组在创建时需要指定长度，且长度一旦确定，无法改变。
数组中元素的类型必须相同。
Java中的数组是对象，继承自 java.lang.Object 类。

在Java中，方法是一段用来执行特定任务的代码块。

2.2 方法

2.2.1 方法的声明和调用

方法通常包括方法名、参数列表和方法体。
方法的声明示例：

public int sum(int a, int b) {
    return a + b;
}

方法的调用示例：

int result = sum(3, 4); // 调用sum方法并传递参数3和4

2.2.2 方法的参数

方法可以接受零个或多个参数，参数用逗号分隔。
参数可以是基本数据类型或对象类型。

2.2.3 方法的返回值

方法可以有返回值，也可以没有（使用 void 表示没有返回值）。
如果方法有返回值，需要使用 return 关键字返回值。

2.2.4 方法重载

Java允许定义多个同名方法，只要它们的参数列表不同（包括参数的类型、顺序或数量）。
编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。

2.2.5 方法的递归

方法可以调用自身，称为递归方法。
需要注意递归方法的结束条件，以避免无限递归导致栈溢出。

2.2.6 方法的作用域

方法可以有不同的访问修饰符，如 public、private、protected 或默认（包级别访问）。

2.2.7 静态方法

使用 static 关键字声明的方法称为静态方法。
静态方法可以通过类名直接调用，无需实例化对象。

2.2.8 方法的重写

在继承中，子类可以重写（覆盖）从父类继承而来的方法。
重写的方法必须具有相同的方法签名（方法名、参数列表和返回类型），并且访问级别不能比父类的方法更严格。

2.2.9 方法的参数传递

Java中的参数传递是按值传递的，即方法接收的是原始值的副本，而不是原始值本身。

三、习题逐语句分析

3.1 求最大值

package day2;

import java.util.Scanner;

public class text1 {
    public static void main(String[] args) {
        //练习一、求最大值
        //定义数组求最大值：55,44,88,66,33,22,77
        int[] arr={55,44,88,66,33,22,77};
        int max = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println("最大的数为："+max);
    }
}

逐语句分析：

数组声明和初始化：

int[] arr={55,44,88,66,33,22,77}; 定义了一个名为arr的整型数组，包含了7个元素，分别是55, 44, 88, 66, 33, 22, 77。

寻找最大值：

int max = arr[0]; 首先将变量max初始化为数组的第一个元素，即55。
for(int i = 1;i < arr.length;i++){...} 使用for循环遍历数组，从索引1开始（因为max已经初始化为索引0的元素），一直到数组的最后一个元素。
if(arr[i] > max){ max = arr[i]; } 在每次迭代中，判断当前元素arr[i]是否大于max，如果是，则更新max的值为arr[i]，这样最终max会存储数组中的最大值。

输出结果：

System.out.println("最大的数为："+max); 打印输出找到的最大值，输出格式为 "最大的数为："加上最大值。

3.2 遍历数组求和

package day2;

import java.util.Random;

public class text2 {
    public static void main(String[] args){
        //练习二、遍历数组求和
        //需求：生成10个1-100的随机数存入数组
        int []arr = new int[10];
        Random r = new Random();
        for (int i = 0; i < 10; i++) {
            int num = r.nextInt(100)+1;
            arr[i] = num;
        }
        //查看是否存入数组中，次步骤只是为了方便验证
        for (int i = 0; i < 10; i++) {
            System.out.print(arr[i]+" ");//print输出的结果不会自动换行
        }
        System.out.println();//仅仅有换行的意思，无特殊含义

        //1.求出所有数据的和
        int sum1 = 0;
        for (int i = 0; i < 10; i++) {
            sum1 += arr[i];
        }
        System.out.println("所有数据的和为"+sum1);

        //2.求所有数据的平均数
        int sum2 = sum1 / 10;
        System.out.println("平均数为"+ sum2);

        //3.统计有多少个数字比平均值小
        int sum3 = 0;
        for(int i = 0;i< 10;i++){
            if(arr[i] < sum2){
                sum3+=1;
            }
        }
        System.out.println("有"+sum3+"个数字比平均值小");
    }
}

逐语句分析：

声明和初始化数组：

int []arr = new int[10];

这行代码创建了一个名为arr的整型数组，包含了10个元素。

生成随机数并存入数组：

Random r = new Random(); for (int i = 0; i < 10; i++) { int num = r.nextInt(100) + 1; arr[i] = num; }

使用Random类生成10个介于1到100之间的随机数，并将每个随机数存储在数组arr的相应位置（索引i）。

打印数组内容：

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

该循环用于输出数组arr中的所有元素。System.out.print用于在同一行打印每个元素，而System.out.println()在循环结束后打印一个空行，用于换行。

求出所有数据的和：

int sum1 = 0; for (int i = 0; i < 10; i++) { sum1 += arr[i]; } System.out.println("所有数据的和为" + sum1);

这段代码计算了数组arr中所有元素的总和，并将结果存储在变量sum1中。最后，使用System.out.println打印出总和。

求所有数据的平均数：

int sum2 = sum1 / 10; System.out.println("平均数为" + sum2);

这里通过简单地将总和sum1除以数组的长度（即10）来计算平均数，并将结果存储在变量sum2中。然后使用System.out.println输出平均数。

统计比平均值小的数字个数：

int sum3 = 0; for (int i = 0; i < 10; i++) { if (arr[i] < sum2) { sum3 += 1; } } System.out.println("有" + sum3 + "个数字比平均值小");

最后一个循环用于遍历数组arr，检查每个元素是否小于平均数sum2，如果是，则将计数器sum3增加1。最后使用System.out.println输出比平均值小的数字的个数。

3.3 交换数字

package day2;

public class text3 {
    public static void main(String[] args){
        //练习三、交换数字
        //需求：定义两个变量，交换两个变量所记录的值.
        int a = 1;
        int b = 2;
        int temp;
        System.out.println("交换之前a:"+a+"b:"+b);
        temp = a;
        a = b;
        b = temp;
        System.out.println("交换之后a:"+a+"b:"+b);
    }
}

逐语句分析：

定义变量并赋初值：

int a = 1; int b = 2;

这里定义了两个整型变量 a 和 b，分别赋值为1和2。

声明临时变量：

int temp;

temp 是一个整型变量，用来临时存储变量 a 的值，以便进行交换操作。

打印交换前的值：

System.out.println("交换之前a:" + a + "b:" + b);

这行代码用于输出变量 a 和 b 的当前值，用于验证交换前的状态

交换变量值：

temp = a; a = b; b = temp;

这里通过使用临时变量 temp，交换了变量 a 和 b 的值。具体步骤是：

将 a 的值赋给 temp，即 temp 现在是1。
将 b 的值（2）赋给 a，即 a 现在是2。
将 temp 的值（1）赋给 b，即 b 现在是1。

打印交换后的值

System.out.println("交换之后a:" + a + "b:" + b);

最后，这行代码输出交换后 a 和 b 的值，以确认交换操作是否成功。

3.4 交换数组元素

package day2;

public class text4 {
    public static void main(String[] args){
        //练习四、交换数组元素
        //需求：将数组中的0索引和最大索引的值交换
        int []arr = {1,2,3,4,5};
        int temp;

        temp = arr[0];
        arr[0] = arr[arr.length-1];
        arr[arr.length-1] = temp;
        System.out.print("交换之后的数组为：");

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

逐语句分析：

定义数组并赋初值：

int []arr = {1, 2, 3, 4, 5};

这里定义了一个整型数组 arr，并初始化为 {1, 2, 3, 4, 5}。

声明临时变量：

int temp;

temp 是一个整型变量，用来临时存储数组第一个元素的值，以便进行交换操作。

交换数组元素：

temp = arr[0]; arr[0] = arr[arr.length - 1]; arr[arr.length - 1] = temp;

temp = arr[0]; 将数组 arr 的第一个元素的值（即 1）赋给 temp。
arr[0] = arr[arr.length - 1]; 将数组 arr 的最后一个元素的值（即 5）赋给数组的第一个元素位置。
arr[arr.length - 1] = temp; 将 temp 的值（即原来的第一个元素 1）赋给数组 arr 的最后一个元素位置，完成了交换操作。

输出交换后的数组：

System.out.print("交换之后的数组为："); for(int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); }

这段代码首先输出提示信息 "交换之后的数组为："，然后通过循环遍历数组 arr 的所有元素，并输出每个元素的值，以空格分隔。

3.5 交换数组元素（进阶）

package day2;

public class text5 {
    public static void main(String[] args) {
        //练习五、交换数组元素（进阶）
        //需求：定义一个数组，存入五个数据，交换首尾索引的元素
        int []arr = {1,2,3,4,5};
        int temp;//定义临时变量方便交换

        System.out.print("交换前数组为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        //数据交换
        for (int i = 0; i < (arr.length/2); i++) {
            temp = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = temp;
        }

        System.out.println();
        System.out.print("交换后数组为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

逐语句分析：

定义数组并赋初值：

int[] arr = {1, 2, 3, 4, 5};

这里定义了一个整型数组 arr，并初始化为 {1, 2, 3, 4, 5}。

声明临时变量：

int temp;

temp 是一个整型变量，用来临时存储数组元素的值，以便进行交换操作。

打印交换前的数组：

System.out.print("交换前数组为："); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); }

这段代码通过循环遍历数组 arr 的所有元素，并输出每个元素的值，以空格分隔。用于展示交换前数组的内容。

数据交换：

for (int i = 0; i < (arr.length / 2); i++) { temp = arr[i]; arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = temp; }

for 循环从数组的开头到中间位置 (arr.length / 2) 进行迭代。
在每次迭代中，使用 temp 临时变量交换 arr[i] 和 arr[arr.length - i - 1] 的值，实现了首尾元素的交换。

打印交换后的数组：

System.out.println(); System.out.print("交换后数组为："); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); }

这段代码首先输出换行符，然后输出提示信息 "交换后数组为："，再次通过循环遍历数组 arr 的所有元素，并输出每个元素的值，以空格分隔。用于展示交换后数组的内容。

3.6 打乱数据

package day2;

import java.util.Random;

public class text6 {
    public static void main(String[] args){
        //练习六、打乱数据
        //需求：打乱数组中有序的数据
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int temp;

        Random r = new Random();
        for(int i = 0; i<arr.length; i++){
            int index = r.nextInt(arr.length);
            temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }

        System.out.print("打乱后的数组为：");
        for(int i = 0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }
}

逐语句分析：

定义数组并赋初值：

int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};

这里定义了一个整型数组 arr，并初始化为 {1, 2, 3, 4, 5, 6, 7, 8, 9}，即按顺序排列的数组。

声明临时变量：

int temp;

temp 是一个整型变量，用来临时存储数组元素的值，以便进行交换操作。

使用 Random 类生成随机数：

Random r = new Random();

Random r 是一个随机数生成器对象，用于生成随机数。

打乱数组数据：

for (int i = 0; i < arr.length; i++) { int index = r.nextInt(arr.length); // 生成一个介于 0 和 arr.length-1 之间的随机数

temp = arr[i];

arr[i] = arr[index];

arr[index] = temp; }

for 循环遍历数组 arr 的每个元素。
r.nextInt(arr.length) 生成一个随机数 index，范围是从 0 到 arr.length-1。
将当前元素 arr[i] 与随机位置 arr[index] 进行交换，从而打乱数组的顺序。

输出打乱后的数组：

System.out.print("打乱后的数组为："); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); }

这段代码输出提示信息 "打乱后的数组为："，然后通过循环遍历数组 arr 的所有元素，并输出每个元素的值，以空格分隔。

3.7 卖飞机票

package day2;

import java.util.Scanner;

public class text7 {
    public static void main(String[] args){
        //练习七、卖飞机票
        //需求：按照收费标准，输出机票原价、月份和头等舱或经济舱
        //价格：旺季（5-10月）头等舱9折，经济舱8.5折
        //淡季（11月到来年4月）头等舱7折，经济舱6.5折
        //1.键盘输入乘客信息
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票原价：");
        double ticket = sc.nextInt();
        System.out.println("请输入月份：");
        int mouth = sc.nextInt();
        System.out.println("请输入舱位，头等舱-0，经济舱-1：");
        int seat = sc.nextInt();
        //2.判断当前所处月份
        if(mouth >=5 && mouth <= 10){//旺季
            if(seat == 0){
                ticket = ticket * 0.9;
            }
            else if(seat == 1){
                ticket = ticket * 0.85;
            }
            else{
                System.out.println("输入舱位有误！！！");
            }
        }
        else if((mouth >= 1 && mouth <= 4) || (mouth >= 11 && mouth <= 12)){//淡季
            if(seat == 0){
                ticket = ticket * 0.7;
            }
            else if(seat == 1){
                ticket = ticket * 0.62;
            }
            else{
                System.out.println("输入舱位有误！！！");
            }
        }
        else{
            System.out.println("输入月份有误！！！");
        }
        System.out.println("您的车票最终价格为："+ticket);
    }
}

逐语句分析：

导入Scanner类：

import java.util.Scanner;

这行代码导入了Java标准库中的 Scanner 类，用于从控制台读取用户输入。

主类 text7 的主方法 main：

public static void main(String[] args) { // 代码实现在这里 }

这是程序的入口点，所有的代码逻辑都在这个方法中执行。

Scanner对象的实例化：

Scanner sc = new Scanner(System.in);

创建了一个 Scanner 对象 sc，并将其初始化为从标准输入（即键盘输入）中读取。

提示用户输入机票原价：

System.out.println("请输入机票原价："); double ticket = sc.nextInt();

使用 System.out.println 输出提示信息，要求用户输入机票的原价。然后使用 sc.nextInt() 从控制台读取一个整数值，并将其赋给 ticket 变量，这里假设机票原价是一个整数。

提示用户输入月份：

System.out.println("请输入月份："); int mouth = sc.nextInt();

同样地，输出提示信息让用户输入月份，然后使用 sc.nextInt() 读取用户输入的整数值，并将其赋给 mouth 变量。

提示用户输入舱位类型：

System.out.println("请输入舱位，头等舱-0，经济舱-1："); int seat = sc.nextInt();

输出提示信息让用户输入舱位类型的选择，使用 sc.nextInt() 读取用户输入的整数值，并将其赋给 seat 变量。在这个代码中，用户输入 0 表示头等舱，输入 1 表示经济舱。

根据月份和舱位类型计算机票价格：

if (mouth >= 5 && mouth <= 10) { // 旺季
    if (seat == 0) {
        ticket = ticket * 0.9; // 头等舱9折
    } else if (seat == 1) {
        ticket = ticket * 0.85; // 经济舱8.5折
    } else {
        System.out.println("输入舱位有误！！！");
    }
} else if ((mouth >= 1 && mouth <= 4) || (mouth >= 11 && mouth <= 12)) { // 淡季
    if (seat == 0) {
        ticket = ticket * 0.7; // 头等舱7折
    } else if (seat == 1) {
        ticket = ticket * 0.62; // 经济舱6.5折
    } else {
        System.out.println("输入舱位有误！！！");
    }
} else {
    System.out.println("输入月份有误！！！");
}

根据用户输入的月份进行判断，如果是旺季（5-10月），则根据舱位类型进行相应的折扣计算；如果是淡季（11月到来年4月），也根据舱位类型进行折扣计算。
如果用户输入的舱位类型不是 0 或 1，则输出错误信息提示用户重新输入。

输出最终的机票价格：

System.out.println("您的车票最终价格为：" + ticket);

最后，输出计算得到的最终机票价格。

3.8 找质数

package day2;

import java.util.Random;

public class text8 {
    public static void main(String[] args) {
        //练习八、找质数
        //需求：判断101-200之间有多少素数，并输出所有素数
        int count=0;
        System.out.println("素数：");
        System.out.println();
        for (int i = 101; i < 201; i++) {
            int flag = 0;
            for (int j = 2; j < i; j++) {
                if(i%j==0){
                    flag = 1;
                    break;
                }
            }
            if(flag==0){
                count+=1;
                System.out.print(i+" ");
            }
        }
        System.out.println("\n"+"101-200之间有"+count+"个素数");
    }
}

逐语句分析：

导入Java标准库中的Random类：

import java.util.Random;

尽管代码中并未使用 Random 类，这个导入语句可以被删除，因为它在当前代码中是多余的。

主类 text8 的主方法 main：

public static void main(String[] args) { // 代码实现在这里 }

这是程序的入口点，所有的代码逻辑都在这个方法中执行。

声明并初始化计数器 count：

int count=0;

count 变量用于统计找到的素数个数，初始化为0。

输出 "素数：" 和一个空行：

System.out.println("素数：");

System.out.println();

这两行代码输出提示信息 "素数：" 和一个空行，用来区分输出素数列表和统计信息。

循环遍历101到200之间的每一个数：

for (int i = 101; i < 201; i++) { // 代码实现在这里 }

for 循环从101开始，到200结束，遍历这个范围内的每一个整数 i。

判断当前数 i 是否为素数：

int flag = 0; for (int j = 2; j < i; j++) { if (i % j == 0) { flag = 1; break; } }

flag 变量用来标记当前数 i 是否被整除。初始设为0表示假设 i 是素数。
内层的 for 循环从2开始，逐个测试 i 是否能被从2到 i-1 的任何数整除。
如果找到一个能整除的数 j，则将 flag 设为1，表示 i 不是素数，并且跳出内层循环。

判断 flag 的值确定是否为素数：

if (flag == 0) {

count += 1; System.out.print(i + " "); }

如果 flag 仍然为0，表示在2到 i-1 的范围内没有找到能整除 i 的数，说明 i 是素数。
打印输出当前找到的素数 i，并将 count 计数器加1。

输出所有素数的数量：

System.out.println("\n" + "101-200之间有" + count + "个素数");

最后打印出101到200之间找到的素数的总数。

3.9 开发验证码

package day2;

import java.util.Random;

public class text9 {
    public static void main(String[] args) {
        //练习九：开发验证码
        //需求：长度为5，前四位为大写字母或小写字母，最后一位是数字
        char []arr=new char[52];
        //将字母存入数组
        for (int i = 0; i < arr.length; i++) {
            if(i<=25){
                arr[i] = (char)(97+i);
            }
            else{
                arr[i] = (char)(65+i-26);
            }
        }
        //生成随机下标
        char []arr2=new char[5];
        Random index=new Random();
        for (int i = 0; i < 4; i++) {
            int index1 = index.nextInt(53);
            arr2[i] = arr[index1];
        }
        int index2 = index.nextInt(10)+48;
        arr2[4] = (char)index2;
        System.out.print("验证码为：");
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]);
        }
    }
}

逐语句分析：

导入Java标准库中的Random类：

import java.util.Random;

这里导入 Random 类以生成随机数。

主类 text9 的主方法 main：

public static void main(String[] args) { // 代码实现在这里 }

这是程序的入口点，所有的代码逻辑都在这个方法中执行。

声明并初始化存储字母的数组 arr：

char[] arr = new char[52];

arr 数组长度为52，用于存储字母。每个字母对应数组中的一个位置。

存储字母到数组 arr：

for (int i = 0; i < arr.length; i++) {
    if (i <= 25) {
        arr[i] = (char) (97 + i);  // 小写字母 'a' 到 'z'
    } else {
        arr[i] = (char) (65 + i - 26);  // 大写字母 'A' 到 'Z'
    }
}

这个循环填充了 arr 数组。当 i 的值小于等于25时，存储小写字母，否则存储大写字母。这样，数组中的前26个位置存储小写字母，后26个位置存储大写字母。

声明并初始化存储验证码的数组 arr2：

char[] arr2 = new char[5];

arr2 数组长度为5，用于存储生成的验证码。

生成随机字母部分的验证码：

Random index = new Random();
for (int i = 0; i < 4; i++) {
    int index1 = index.nextInt(52);
    arr2[i] = arr[index1];
}

在这个循环中，使用 Random 类生成一个随机整数 index1，范围从0到51，然后根据 index1 选择 arr 数组中对应位置的字母。这样循环四次，生成前四位随机字母部分的验证码。

生成随机数字部分的验证码：

int index2 = index.nextInt(10) + 48;  // 生成随机数字，范围是 '0' 到 '9'
arr2[4] = (char) index2;

这里生成一个随机整数 index2，范围从0到9，然后加上48，得到ASCII码对应的数字字符。将这个字符存储在 arr2 数组的最后一个位置，确保验证码的最后一位是数字。

输出生成的验证码：

System.out.print("验证码为："); for (int i = 0; i < arr2.length; i++) { System.out.print(arr2[i]); }

最后，打印输出生成的完整验证码，将前面生成的 arr2 数组中的字符逐个输出。

3.10 评委打分

package day2;

import java.util.Arrays;
import java.util.Random;

public class text10 {
    public static void main(String[] args) {
        //练习十：评委打分
        //需求：6名评委打分，范围是0-100之间的整数，选手的最终得分为去掉一个最低分和最高分后的平均分，计算选手得分
        int [] arr = new int[6];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(101);
        }
        Arrays.sort(arr);
        int sum = 0;
        for (int i = 1; i < arr.length-1; i++) {
            sum+=arr[i];
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("选手的最终得分为"+sum/4);
    }
}

逐语句分析：

主类 text10 的主方法 main：

public static void main(String[] args) { // 代码实现在这里 }

这是程序的入口点，所有的代码逻辑都在这个方法中执行。

声明并初始化评委打分的数组 arr：

int[] arr = new int[6];

arr 数组长度为6，用于存储6名评委的打分。

生成随机评委打分：

Random r = new Random();
for (int i = 0; i < arr.length; i++) {
    arr[i] = r.nextInt(101);  // 生成0到100之间的随机整数，包括0和100
}

使用 Random 类生成随机整数，范围在0到100之间，将这些随机数存储在 arr 数组中，模拟每名评委的打分。

对打分数组 arr 进行排序：

Arrays.sort(arr);

使用 Arrays.sort() 方法对 arr 数组进行排序。排序后，数组中的元素从小到大排列。

计算去掉最低分和最高分后的总分：

int sum = 0; for (int i = 1; i < arr.length - 1; i++) { sum += arr[i]; }

这个循环从数组的第二个元素开始累加到倒数第二个元素，即去掉了最低分 arr[0] 和最高分 arr[5]。累加得到的 sum 是去掉最低分和最高分后的总分。

输出评委打的分数：

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

这段代码打印出每位评委打的分数，用于查看每位评委的具体评分情况。

计算并输出选手的最终得分：

System.out.println("选手的最终得分为" + sum / 4);

最后，打印输出计算得到的选手的最终得分。由于去掉了两个分数（最低分和最高分），所以平均分数是总分 sum 除以4。

3.11 数字加密（四位数）

package day2;

import java.util.Scanner;

public class text11 {
    public static void main(String[] args) {
        //练习11：数字加密(四位数)
        //需求：输入一个数进行加密输出
        //规则：先得到每位数，然后对每位数加5，在对10取余，最后将所有数字反转，得到一串新数
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入你要加密的数字：");
        int n = sc.nextInt();
        int num1;
        int num2;
        int []arr = new int[4];
        for (int i = 0; i < 4; i++) {
            num1 = n%10;//num1存放原数字的每一位
            n/=10;
            num2 = (num1+5) % 10;//num2存放加密后的数字
            arr[i] = num2;
        }
        System.out.print("加密后的结果为：");
        for (int i = 0; i < 4; i++) {
            System.out.print(arr[i]);
        }
    }
}

逐语句分析：

导入 Scanner 类：

import java.util.Scanner;

这行代码导入了 java.util.Scanner 类，用于从标准输入（键盘）读取用户输入的数据。

主类 text11 的主方法 main：

public static void main(String[] args) { // 代码实现在这里 }

这是程序的入口点，所有的代码逻辑都在这个方法中执行。

创建 Scanner 对象 sc：

Scanner sc = new Scanner(System.in);

这行代码创建了一个 Scanner 对象 sc，用于接收用户的输入。

提示用户输入要加密的数字：

System.out.print("请输入你要加密的数字：");

这行代码输出一条提示信息，要求用户输入一个要加密的四位数。

读取用户输入的数字：

int n = sc.nextInt();

sc.nextInt() 方法从键盘读取用户输入的整数，并将其赋值给变量 n。

定义变量和数组：

int num1; int num2; int[] arr = new int[4];

num1 和 num2 是用来存放数字计算中间结果的变量。
arr 是一个长度为4的整型数组，用来存放加密后的每一位数字。

进行加密操作：

for (int i = 0; i < 4; i++) {
    num1 = n % 10;          // num1存放原数字的每一位
    n /= 10;                // 原数字去掉最后一位
    num2 = (num1 + 5) % 10; // num2存放加密后的数字
    arr[i] = num2;          // 将加密后的数字存入数组
}

输出加密后的结果：

System.out.print("加密后的结果为：");
for (int i = 0; i < 4; i++) {
    System.out.print(arr[i]);
}

首先输出 "加密后的结果为：" 提示信息。
然后通过 for 循环逐个输出数组 arr 中存储的加密后的每一位数字。

3.12 抢红包

package day2;

import java.util.Random;

public class text12 {
    public static void main(String[] args) {
        //练习12：抢红包
        //需求：有一个红包金额为{2,588,888,1000,10000}。使用代码模拟抢红包，不可有重复红包出现。（随机顺序）
        int []arr= {2,588,888,1000,10000};
        int []newarr=new int[arr.length];

        Random rand = new Random();
        for (int i = 0; i < 5;) {
            int index = rand.nextInt(arr.length);//下标为0-4
            int prize = arr[index];//红包金额
            boolean flag = one(newarr, prize);//标记
            if (!flag) {
                newarr[i] = prize;
                i++;
            }
        }
        for (int i = 0; i < newarr.length; i++) {
            System.out.println(newarr[i]);
        }
    }
    //判断price是否在数组中
    //存在：true，不存在：false
    public static boolean one(int []arr,int price) {
        for(int i=0;i<arr.length;i++){
            if(arr[i]==price){
                return true;
            }
        }
        return false;
    }
}

逐语句分析：

定义 text12 类：

package day2; import java.util.Random; public class text12 {

这段代码定义了一个名为 text12 的类，并放置在 day2 包中。它使用了 java.util.Random 类来生成随机数。

主方法 main：

public static void main(String[] args) { // 代码实现在这里 }

这是程序的入口点，所有的代码逻辑都在这个方法中执行。

定义红包金额数组和结果数组：

int[] arr = {2, 588, 888, 1000, 10000};

int[] newarr = new int[arr.length];

arr 数组存放了几个固定的红包金额。
newarr 数组用来存放抢到的红包金额，初始化与 arr 相同长度。

创建 Random 对象 rand：

Random rand = new Random();

这行代码创建了一个 Random 对象 rand，用于生成随机数。

抢红包的逻辑：

for (int i = 0; i < 5;) {
    int index = rand.nextInt(arr.length); // 生成一个0到arr.length-1之间的随机数
    int prize = arr[index]; // 获取对应随机下标的红包金额
    boolean flag = one(newarr, prize); // 调用one方法判断红包金额是否已经被抢过
    if (!flag) {
        newarr[i] = prize; // 如果未被抢过，则将该红包金额存入newarr数组中
        i++; // i自增，继续下一轮抢红包
    }
}

for 循环控制抢红包的次数，这里设定为抢5个红包。
rand.nextInt(arr.length) 生成一个0到 arr.length-1 之间的随机数作为红包数组 arr 的下标。
int prize = arr[index]; 根据随机下标获取对应的红包金额。
boolean flag = one(newarr, prize); 调用 one 方法判断当前红包金额是否已经在 newarr 中出现过。
如果 flag 为 false，表示该红包金额尚未被抢过，则将其存入 newarr 数组中，并递增 i，继续下一轮抢红包。

输出抢到的红包金额：

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

这段代码通过 for 循环遍历 newarr 数组，依次输出抢到的红包金额。

判断红包金额是否已存在的方法 one：

public static boolean one(int[] arr, int price) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == price) {
            return true;
        }
    }
    return false;
}