2021-9-26-日常学习13-基础知识练习

最新推荐文章于 2026-02-23 01:19:46 发布
原创 最新推荐文章于 2026-02-23 01:19:46 发布 · 546 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
本文通过一系列编程案例介绍了如何使用if语句和switch语句进行条件判断，以及利用for循环处理数据。案例涵盖了减肥计划、逢七过、兔子繁殖、数组元素求和、数组内容比较、查找、反转、评委打分等实际问题，展示了条件判断和循环在解决实际问题中的应用。

案例1：减肥计划（if）

需求：输入星期数，显示今天的减肥活动

思路：

①键盘录入一个星期数，用一个变量接收

②对星期数进行判断，这里用if语句实现

③在对应的语句控制中输出对应的减肥活动

需求：输入星期数，显示今天的减肥活动

周一：跑步

周二：游泳

周三：慢走

周四：动感单车

周五：拳击

周六：爬山

周日：好好吃一顿

/*
    需求：输入星期数，显示今天的减肥活动
        周一：跑步
        周二：游泳
        周三：慢走
        周四：动感单车
        周五：拳击
        周六：爬山
        周日：好好吃一顿

    思路：
        ①键盘录入一个星期数，用一个变量接收
        ②对星期数进行判断，这里用if语句实现
        ③在对应的语句控制中输出对应的减肥活动
 */

import java.util.Scanner;

public class basicsTest01 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个星期数：");
        int week =sc.nextInt();

        //对星期数进行判断，这里用if语句
        if (week < 1 || week > 7){
            System.out.println("你输入的星期数有误");
        }else if(week == 1){
            System.out.println("跑步");
        }else if(week == 2){
            System.out.println("游泳");
        }else if(week == 3){
            System.out.println("慢走");
        }else if(week == 4){
            System.out.println("动感单车");
        }else if(week == 5){
            System.out.println("拳击");
        }else if(week == 6){
            System.out.println("爬山");
        }else if(week == 7){
            System.out.println("好好吃一顿");
        }
    }
}

运行：

请输入一个星期数：
7
好好吃一顿

案例2：减肥计划（switch）

需求：输入星期数，显示今天的减肥活动

思路：

①键盘录入一个星期数，用一个变量接收

②对星期数进行判断，这里用switch语句实现

③在对应的语句控制中输出对应的减肥活动

需求：输入星期数，显示今天的减肥活动

周一：跑步

周二：游泳

周三：慢走

周四：动感单车

周五：拳击

周六：爬山

周日：好好吃一顿

*注：导报小技巧！

导包：

①手动导包        import java.util.Scanner;

②快捷键导包    Scanner + Alt + Enter

③自动导包        输入Scanner的时候 上下键导包

细节：

①手动导包

import java.util.Scanner;

public class basicsTest02 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量个接收

         Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        }

}

②：第一种方法，选中Scanner点击 ALt + 回车 ，自动加载 import java.util.Scanner;

public class basicsTest02 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量个接收

         Scanner sc = new Scanner(System.in);// 这个选中Scanner按Alt + Enter

        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        }

}

👇 

import java.util.Scanner;

public class basicsTest02 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量个接收

         Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        }

}

/*
    需求：输入星期数，显示今天的减肥活动
        周一：跑步
        周二：游泳
        周三：慢走
        周四：动感单车
        周五：拳击
        周六：爬山
        周日：好好吃一顿

    思路：
        ①键盘录入一个星期数，用一个变量接收
        ②对星期数进行判断，这里用switch语句实现
        ③在对应的语句控制中输出对应的减肥活动

    导包：
        ①手动导包     import java.util.Scanner;
        ②快捷键导包    Scanner + Alt + Enter
        ③自动导包     输入Scanner的时候 上下键导包
 */

import java.util.Scanner;

public class basicsTest02 {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量个接收

         Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        //对星期数进行判断，这里用switch语句实现
        switch(week) {
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("动感单车");
                break;
            case 5:
                System.out.println("拳击");
                break;
            case 6:
                System.out.println("爬山");
                break;
            case 7:
                System.out.println("好好吃一段");
                break;
            default:
                System.out.println("你输入的星期数有误");
        }
    }
}

运行：

请输入一个星期数：
7
好好吃一段

案例3：逢七过

需求：朋友聚会的时候可能会玩一个游戏，逢七过。规则是：从任意一个数字开始报数，当你要报的数字包含7，或者是7的倍数时都要说：过。为了帮助大家更好的玩这个游戏，这里我们直接在控股台打印出1-100之间满足逢七过规则的数据。这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。

思路：

①数据在1-100之间，用for循环实现数据的获取

②根据规则，用if语句实现数据的判断：要么各个位时7，要么十位是7，要么能被7整除

x % 10 == 7                x / 10 %10 == 7                x % 7 ==0

/*
    需求：
        朋友聚会的时候可能会玩一个游戏，逢七过。规则是：从任意一个数字开始报数，
    当你要报的数字包含7，或者是7的倍数时都要说：过。为了帮助大家更好的玩这个游戏，
    这里我们直接在控股台打印出1-100之间满足逢七过规则的数据。这样，大家将来在玩游戏的时候，
    就知道哪些数据要说：过。

    思路：
        ①数据在1-100之间，用for循环实现数据的获取
        ②根据规则，用if语句实现数据的判断：要么各个位时7，
        要么十位是7，要么能被7整除
        x % 10 == 7         x / 10 %10 == 7        x % 7 ==0
 */
public class basicsTest3 {
    public static void main(String[] args) {
        //数据在1-100之间，用for循环实现数据的获取
        for (int x = 1; x <= 100; x++) {
            //根据规则，用if语句实现数据的判断：要么各个位时7，要么十位是7，要么能被7整除
            if(x%10==7 || x/10%10 == 7 || x%7==0){
                //在控制台输出满足规则的数据
                System.out.println(x);
            }
        }
    }
}

运行：

7
14
17
21
27
28
35
37
42
47
49
56
57
63
67
70
71
72
73
74
75
76
77
78
79
84
87
91
97
98

案例4：不死兔子

需求：有一对兔子，从出生后第三个月起每个月都生一对兔子，小兔子长到第三个月后，每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

找规律：

第一个月：1

第二个月：1

第三个月：2

第四个月：3

第五个月：5

...

数据连起来：1，1，2，3，5

规律：从第三个数据开始，每个数据都是前两个数据之和。第一个，第二个数据是一致的。

用数组模拟：

arr[0] = 1;

arr[1] = 1;

arr[2] = arr[0] + arr[1];

arr[3] = arr[1] + arr[2];

...

思路：

①为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20

②因为第一个月，第二个月兔子的对数是已知的，都是1，所以数组的第一个元素，第二个元素值也都是1

③用循环实现计算每个月的兔子对数

for(int x = ?; x < ?; x++){

        规律

}

④输出数组中最后一个元素的值，就是第20个月的兔子对数

/*
    需求：有一对兔子，从出生后第三个月起每个月都生一对兔子，小兔子长到第三个月后，
每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

    思路：
        ①为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
        ②因为第一个月，第二个月兔子的对数是已知的，都是1，所以数组的第一个元素，
        第二个元素值也都是1
        ③用循环实现计算每个月的兔子对数
        ④输出数组中最后一个元素的值，就是第20个月的兔子对数
 */
public class basicsTest04 {
    public static void main(String[] args) {
        //为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
        int[] arr = new int[20];

        //因为第一个月，第二个月兔子的对数是已知的，都是1，所以数组的第一个元素，第二个元素值也都是1
        arr[0] = 1;
        arr[1] = 1;

        //arr[2] = arr[0]+arr[1];
        //arr[3] = arr[2]+arr[1];
        //arr[4] = arr[3]+arr[2];

        //for循环实现计算每个月的兔子对数
        for(int x=2;x<arr.length;x++){
            arr[x] = arr[x-2] +arr[x-1];
        }
        //输出数组中最后一个元素的值，就是第20个月的兔子对数
        System.out.println("第二十个月兔子的对数：" + arr[19]);
    }
}

运行：

第二十个月兔子的对数：6765

案例5：百钱百鸡

需求：我国古代数学家张丘健《算经》一书中提出的数学问题，鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一，百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

分析：

假设鸡翁 x 只，鸡母 y 只,鸡雏 z 只，则成为式子为：

x + y + z =100;

5*x + 3*y + z/3 = 100;

/*

如果单独只看一只鸡型，则下面的式子是成立的

0 <= x <= 20

0 <= y <= 33

0 <= z <=100

使用后穷举发就可以罗列出x,y,z的值

*/

思路：

①第一层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x=0，判断条件是x<=20

②第二层循环，用于表示鸡母的范围，初始化表达式的变量定义为y=0，判断条件是y<=33

③这个时候，用于表示鸡雏的变量z = 100 - x - y

④判断表达式 z % 3 == 0 的表达式 5*x + 3*y + z/3 = 100;是否同时成立，如果成立，输出对应的x,y,z的值，就是对应的鸡翁，鸡母，鸡雏的值

/*
    需求：
        我国古代数学家张丘健《算经》一书中提出的数学问题，鸡翁一值钱五，
        鸡母一值钱三，鸡雏三值钱一，百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
    思路：
        ①第一层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x=0，判断条件是x<=20
        ②第二层循环，用于表示鸡母的范围，初始化表达式的变量定义为y=0，判断条件是y<=33
        ③这个时候，用于表示鸡雏的变量z = 100 - x - y
        ④判断表达式 z % 3 == 0 的表达式 5*x + 3*y + z/3 = 100;是否同时成立，如果成立，
        输出对应的x,y,z的值，就是对应的鸡翁，鸡母，鸡雏的值
 */
public class basicsTest05 {
    public static void main(String[] args) {
        //第一层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x=0，判断条件是x<=20
        for(int x = 0; x <= 20;x++){
            //第二层循环，用于表示鸡母的范围，初始化表达式的变量定义为y=0，判断条件是y<=33
            for (int y = 0; y <= 33;y++){
                //这个时候，用于表示鸡雏的变量z = 100 - x - y
                int z = 100 -x- y;

                //判断表达式 z % 3 == 0 的表达式 5*x + 3*y + z/3 = 100;是否同时成立
                if(z % 3 == 0&& 5*x + 3*y + z/3 == 100){
                    System.out.println(x+","+y+","+z);
                }
            }
        }
    }
}

运行：

0,25,75
4,18,78
8,11,81
12,4,84

案例6：数组元素求和

需求：有这样的一个数组，元素是{68，27，95，88，171，996，51，210}，求出该数组中满足要求的元素和，要起诉hi，求和的元素个位和十位都不能是7，并且只能是偶数

思路：

①定义一个数组，用静态初始化完成数组元素的初始化

②定义一个求和变量，初始值是0

③遍历数组，获取到数组中的每一个元素

④判断该元素是否满足条件，如果满足条件就累加

arr[x] % 10 != 7        arr[x] / 10 % 10 != 7        arr[x] % 2 == 0

⑤输出求和变量的值

/*
    需求：
        有这样的一个数组，元素是{68，27，95，88，171，996，51，210}，
        求出该数组中满足要求的元素和，要起诉hi，求和的元素个位和十位都不能是7，
        并且只能是偶数

    思路：
        ①定义一个数组，用静态初始化完成数组元素的初始化
        ②定义一个求和变量，初始值是0
        ③遍历数组，获取到数组中的每一个元素
        ④判断该元素是否满足条件，如果满足条件就累加
        arr[x] % 10 != 7;  arr[x] / 10 % 10 != 7;  arr[x] % 2 == 0;
        ⑤输出求和变量的值
 */
public class basicsTest06 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {68,27,95,88,171,996,51,210};

        //定义一个求和变量，初始值是0
        int sum = 0;

        //遍历数组，获取到数组中的每一个元素
        for(int x = 0; x < arr.length; x++){
            if(arr[x] % 10 != 7 && arr[x] / 10 % 10 != 7 && arr[x] % 2 ==0 ){
                sum += arr[x];
            }
        }
        System.out.println("sum:" + sum);
    }
}

运行：

sum:1362

案例7：数组内容相同

需求：设计一个方法，用于比较两个数组的内容是否相同

思路：

①定义两个数组，分别使用静态初始化完成数组元素的初始化

②定义一个方法，用于比较两个数组的内容是否是相同

        返回值类型：boolean

        参数：int[] arr, int[] arr2

③比较两个数组的内容是否相同，按照下面的步骤实现就可以

首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回值false

其次遍历，比较两个数组中的每个元素，只要有元素不相同，返回值false

最后循环遍历结束后，返回true

④调用方法，用变量接收

⑤输出结果

/*
    需求：设计一个方法，用于比较两个数组的内容是否相同
    思路：
        ①定义两个数组，分别使用静态初始化完成数组元素的初始化
        ②定义一个方法，用于比较两个数组的内容是否是相同
        返回值类型：boolean
        参数：int[] arr, int[] arr2
        ③比较两个数组的内容是否相同，按照下面的步骤实现就可以
            首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回值false
            其次遍历，比较两个数组中的每个元素，只要有元素不相同，返回值false
            最后循环遍历结束后，返回true
        ④调用方法，用变量接收
        ⑤输出结果
 */
public class basicsTest07 {
    public static void main(String[] args) {
        //定义两个数组，分别使用静态初始化完成数组元素的初始化
        int[] arr = {11,22,33,44,55};
        int[] arr2 = {11,22,33,44,55};

        //调用方法，用变量接收
        boolean flag = compare(arr,arr2);
        //输出结果
        System.out.println(flag);
    }
    //定义一个方法，用于比较两个数组的内容是否是相同
    /*
    两个明确：
            返回值类型：boolean
        参数：int[] arr, int[] arr2
     */
    public static boolean compare(int[] arr,int[] arr2){
        //首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回值false
        if(arr.length != arr2.length){
            return false;
        }

        //其次遍历，比较两个数组中的每个元素，只要有元素不相同，返回值false
        for(int x = 0; x < arr.length; x++){
            if(arr[x] != arr2[x]){
                return false;
            }
        }

        //最后循环遍历结束后，返回true
        return true;
    }
}

运行：

true

案例8：查找

需求：已知，一个数组 arr = {19，28，37，46，50}；键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到索引值

数据1928374650
索引01234

分析：

键盘录入一个数据后，让这个数据和数组中的每一个元素进行比较，如果数据值相等，返回该数据值对应的索引即可。

思路：

①定义一个数组，用静态初始化完成数组元素的初始化

②键盘录入要查找的数据，用一个变量接收

③定义一个索引变量，初始值为-1

④遍历数组，获取到数组中的每一个元素

⑤拿键盘录入的数据和数据组中的每一个元素进行比较，如果值相同，就把改制对应的索引赋值给索引变量，并结束循环

⑥输出索引变量

import java.util.Scanner;

/*
    需求：
        已知，一个数组 arr = {19，28，37，46，50}；
    键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到索引值

    思路：
        ①定义一个数组，用静态初始化完成数组元素的初始化
        ②键盘录入要查找的数据，用一个变量接收
        ③定义一个索引变量，初始值为-1
        ④遍历数组，获取到数组中的每一个元素
        ⑤拿键盘录入的数据和数据组中的每一个元素进行比较，
        如果值相同，就把改制对应的索引赋值给索引变量，并结束循环
        ⑥输出索引变量
 */
public class basicsTest08 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19,28,37,46,50};

        //键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入要查找的数据");
        int number = sc.nextInt();

        /*
        //定义一个索引变量，初始值为-1
        int index = -1;

        //遍历数组，获取到数组中的每一个元素
        for(int x = 0; x < arr.length; x++){
            //拿键盘录入的数据和数据组中的每一个元素进行比较，如果值相同，
            // 就把改制对应的索引赋值给索引变量，并结束循环
            if(arr[x] == number){
                index = x;
                break;
            }
        }
        */

        //调用方法
        int index = getIndex(arr,number);

        //输出索引变量
        System.out.println("index:" + index);
    }
    //查找指定的数据在数组中的索引
    /*
        两个明确：
            返回值类型：int
            参数：int[] arr, int number
     */
    public static int getIndex(int[] arr,int number){
        //定义一个索引变量，初始值为-1
        int index = -1;

        //遍历数组，获取到数组中的每一个元素
        for(int x = 0; x < arr.length; x++){
            //拿键盘录入的数据和数据组中的每一个元素进行比较，如果值相同，
            // 就把改制对应的索引赋值给索引变量，并结束循环
            if(arr[x] == number){
                index = x;
                break;
            }
        }
        //返回索引
        return index;
    }
}

运行：

请输入要查找的数据
37
index:2

案例9：反转

需求：已知一个数组 arr = {19,28,37,46,50};用程序是先把数组中的元素值交换，

           交换后的数组 arr = {50,46,37,28,19};并在控制台输出交换后的数组元素

数据1928374650
索引01234

👇反转后👇

数据5046372819
索引01234

分析：

第一个元素和最后一个元素交换

第二个元素和倒数第二个元素交换

第三个元素和倒数第三个元素交换

...

 思路：

①定义一个数组，用静态初始化完成数组元素的初始化

②循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引 <= 结束索引

③变量交换

④遍历数组

第一种方法：

/*
    案例：反转
    需求：已知一个数组 arr = {19,28,37,46,50};用程序是先把数组中的元素值交换，
       交换后的数组 arr = {50,46,37,28,19};并在控制台输出交换后的数组元素
    思路：
        ①定义一个数组，用静态初始化完成数组元素的初始化
        ②循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引
        <= 结束索引
        ③变量交换
        ④遍历数组
 */
public class basicsTest09 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};

        //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引<= 结束索引
        for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
            //变量交换（这里是临时变量）
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        //遍历数组
        printArray(arr);
    }

    /*
        连个明确：
            返回值：void
            参数：int[] arr
     */
    public static void printArray(int[] arr) {
        System.out.print("[");

        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ",");
            }
        }
        System.out.println("]");
    }
}

 运行：

[50,46,37,28,19]

 第二种方法：（这里用反转方法）

/*
    案例：反转
    需求：已知一个数组 arr = {19,28,37,46,50};用程序是先把数组中的元素值交换，
       交换后的数组 arr = {50,46,37,28,19};并在控制台输出交换后的数组元素
    思路：
        ①定义一个数组，用静态初始化完成数组元素的初始化
        ②循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引
        <= 结束索引
        ③变量交换
        ④遍历数组
 */
public class basicsTest09_2 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};

        //调用反转方法
        reverse(arr);

        //遍历数组
        printArray(arr);
    }

    //创建反转方法
    /*
        连个明确：
            返回值：void
            参数：int[] arr
     */
    public static void reverse(int[] arr) {
        //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引<= 结束索引
        for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
            //变量交换（这里是临时变量）
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }
    /*
        连个明确：
            返回值：void
            参数：int[] arr
     */

    public static void printArray(int[] arr) {
        System.out.print("[");

        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ",");
            }
        }
        System.out.println("]");
    }
}

运行：

[50,46,37,28,19]

案例10：评委打分

 需求：在编程竞赛中，有六个评委为参赛选手打分，分数为0-100的整数分。

            选手的最后得分为：去掉一个最高分和一个最低分后的，四个评委平均值（不考虑小数部分）。

思路：

①定义一个数组，用动态初始化完成数组元素的初始化，长度为6

②键盘录入评委分数

③由于是6个评委打分，所以，接收评委分数的操作

④定义方法实现获取数组中的最高分（数组最大值），调用方法

⑤定义方法实现获取数组中的最低分（数组最小值），调用方法

⑥定义方法实现获取数组中的所有元素的和（数组元素求和），调用方法

⑦按照计算规则进行计算得到平均分

⑧输出平均分

/*
    案例：评委打分
    需求：在编程竞赛中，有六个评委为参赛选手打分，分数为0-100的整数分。
       选手的最后得分为：去掉一个最高分和一个最低分后的，四个评委平均值（不考虑小数部分）。

    思路：
        ①定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        ②键盘录入评委分数
        ③由于是6个评委打分，所以，接收评委分数的操作
        ④定义方法实现获取数组中的最高分（数组最大值），调用方法
        ⑤定义方法实现获取数组中的最低分（数组最小值），调用方法
        ⑥定义方法实现获取数组中的所有元素的和（数组元素求和），调用方法
        ⑦按照计算规则进行计算得到平均分
        ⑧输出平均分
 */

import java.util.Scanner;

public class basicsTest10 {
    public static void main(String[] args) {
        //定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];

        //键盘录入评委分数
        Scanner sc = new Scanner(System.in);

        /*
        System.out.println("请输入第一个评委的评分:");
        arr[0] = sc.nextInt();

        System.out.println("请输入第二个评委的评分:");
        arr[1] = sc.nextInt();

        System.out.println("请输入第三个评委的评分:");
        arr[2] = sc.nextInt();

        System.out.println("请输入第四个评委的评分:");
        arr[3] = sc.nextInt();

        System.out.println("请输入第五个评委的评分:");
        arr[4] = sc.nextInt();

        System.out.println("请输入第六个评委的评分:");
        arr[5] = sc.nextInt();
        */

        //由于是6个评委打分，所以，接收评委分数的操作
        for(int x = 0; x <arr.length; x++){
            System.out.println("请输入第" + (x + 1) + "个评委的评分:");
            arr[x] = sc.nextInt();
        }
        //printArray(arr);

        //定义方法实现获取数组中的最高分（数组最大值），调用方法
        int max = getMax(arr);

        //定义方法实现获取数组中的最低分（数组最小值），调用方法
        int min = getMin(arr);

        //定义方法实现获取数组中的所有元素的和（数组元素求和），调用方法
        int sum = getSum(arr);

        //按照计算规则进行计算得到平均分
        int avg = (sum - max - min) / (arr.length - 2);

        //输出平均分
        System.out.println("选手的最终得分是：" + avg);
    }

    /*
       两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getSum(int[] arr) {
        int sum = 0;

        for (int x = 0; x < arr.length; x++) {
            sum += arr[x];
        }
        return sum;
    }


    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMin(int[] arr){
        int min = arr[0];

        for(int x = 1;x < arr.length; x++){
            if(arr[x] < min){
                min = arr[x];
            }
        }
        return min;
    }
    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMax(int[] arr){
        int max = arr[0];

        for(int x = 1; x < arr.length; x++){
            if(arr[x] > max){
                max = arr[x];
            }
        }
        return  max;

    }

    //遍历数组
    public static void printArray(int[] arr){
        System.out.println("[");

        for(int x = 0; x < arr.length; x++){
            if(x ==arr.length - 1){
                System.out.println(arr[x]);
            }else{
                System.out.println(arr[x] + ",");
            }
        }
        System.out.println("]");
    }
}

运行：

请输入第1个评委的评分:
97
请输入第2个评委的评分:
89
请输入第3个评委的评分:
99
请输入第4个评委的评分:
98
请输入第5个评委的评分:
88
请输入第6个评委的评分:
95
选手的最终得分是：94

eclipse快捷键大全（史上最全）
10-26
eclipse快捷键大全 最新版本的 eclipse 快捷键 myeclipse一样可以。
Java入门第12天 （方法重载 ，方法的参数传递）
weixin_51599540的博客
11-03 770
需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整类型（byte ，short ，int ，long） 7:方法的参数传递 （1）：对于引用类型的参数，形式参数的改变，影响实际参数的值。 * 案例：需求：输入星期数，显示今天的减肥活动 周一：跑步 周二：游泳 周三：动感单车 周四：拳击 周五：爬山 周六：慢跑 周日：休息 思路： 1：键盘录入一个星期数，用一个变量接收 2：对星期数进行判断，这里用if语句 3：在对应的语句中输出对应的减肥活动 */ package com.Sca
减肥计划案例
m0_51664084的博客
02-21 360
减肥计划案例，Java基础，Java案例，Java代码，Java相关内容。​ 需求：输入星期数，显示今天的减肥活动。 周一：跑步 周二：游泳 周三：慢走 周四：动感单车 周五：拳击 周六：爬山 周日：好好吃一顿 import java.util.Scanner; public class LoseWeightPlan { public static void main(String[] args) { Scanner sc = new Scanner(System.in); i
基础知识案例练习
m0_49128301的博客
11-03 542
案例1：减肥计划 需求：输入星期数，显示今天的减肥活动 周一：跑步 周二：游泳 周三：慢走 周四：动感单车 周五：拳击 周六：爬山 周日：好好吃一顿 减肥计划if版 package com.itheima; import java.util.Scanner; /* * 需求：输入星期数，显示今天的减肥活动 周一：跑步 周二：游泳 周三：慢走 周四：动感单车 周五：拳击 ...
java实现减肥计划（if判断运用和switch运用）
liangruilz的博客
03-31 910
java实现减肥计划（if判断运用和switch运用） 注意:IntelliJ IDEA 2019.3出现@Test测试时，键盘输入卡住问题解决 代码： package com.liangrui; import org.junit.Test; import java.util.Scanner; /** * 功能描述： 减肥计划 * 输入星期数，显示今天的减肥活动 * 周一：跑步 * 周二：游泳 * 周三：慢走 * 周四：动感单车 *
Scanner类的创建及使用
m0_73475175的博客
10-31 1752
Scanner类的创建及使用
Python学习目录
热门推荐
吉大秦少游
05-19 4万+
目录 基础知识学习（MOOC：嵩天） 1.1 Python MOOC练习3 1.2 Python MOOC练习4 1.3 python中的随机函数random的用法示例 1.4 Python文本词频统计的编码问题-MOOC嵩天 1.5 Python中的复数和误区 1.6 Python计算圆周率的两种方法 1.7 Python实现七段数码管显示效果 1.8 Python实现科赫图形设计 1.9 ...
【2021 第一期】日常开发 26 个常见的 JavaScript 代码优化方案
小鹿动画学编程
02-18 1万+
大伙儿好~，我是小鹿，公众号：「小鹿动画学编程」 原创作者。 时隔半年我又回来了，期间发生了很多事情。从大学刚毕业来到一线找工作，也由于今年出现的特殊情况，掘金断就更了一段时间。嗯～，就不给自己找借口啦。现在全部安顿好了，把精力开始慢慢回归到写作上，希望在 2021 新的一年和大伙儿一起在掘金成长！ 2021 第一期。 本篇文章整理了在日常开发中 30 个常见的 JavaScript 代码优化方案。 本文章已在 Github blog 收录，欢迎大伙儿～ Star，文章中若存在不足或者 issues.
仅需一行代码，超绝完成26个日常任务
m0_75067629的博客
05-28 971
通过这些实例，你不仅能够学习到Python的基础知识，还能掌握一些高效编码的小技巧。
优学派学习机P36，P26，E26和P60选哪个
2301_80084894的博客
02-07 590
此外，P36内置了丰富的学习资源，从小学到中学的全科课程一应俱全，还有针对英语学习的专项强化训练，通过智能分析孩子的学习情况，精准推送个性化学习方案，让学习更加高效、有针对性。更有趣的是，内置的AR互动功能，让抽象的知识点变得生动有趣，比如通过三维模型展示化学分子结构，或是模拟物理实验过程，让学习变得直观易懂，极大地激发了孩子们的探索欲和学习兴趣。而13.8英寸的巨屏搭配2.5K圆偏振光护眼屏，不仅带来了震撼的视觉体验，更通过先进的护眼技术，有效减少蓝光伤害，守护孩子的视力健康。优学派AI学习机P26。
大数据学习日常小练习题汇总收纳
北慕辰的博客，欢迎各位大佬光临！！
06-22 8110
仅供学习交流使用 一、选择题 1.下面哪个程序负责 HDFS 数据存储。 A、NameNode B、Jobtracker C、Datanode D、secondaryNameNode 答案：C 2.HDFS 中的 block 默认保存几份？ A、3份 B、2份 C、1份 D、不确定 答案：A 3.hadoop2.x版本之后 HDFS 默认 Block Size。 A、32MB B、64MB C、128MB D、256MB 答案：C 4.大数据集群的主要瓶颈是 A、CPU B、网络 C、磁盘IO D、内存 答
1行Python搞定高频任务！26个实用技巧解决日常+进阶需求
08-19 900
本文分享26个Python极简代码技巧，分日常任务（20个）和进阶技巧（6个），含具体代码及通俗解释。覆盖列表处理、字符串操作、错误处理等需求，帮读者用简洁代码解决问题，提升编码效率。
日常练习week1
Tttttttimer的博客
11-18 609
——从i春秋的基础分类开始做起—— 1.小苹果 下载就是一个很普通的小苹果.wav，这是我第一见到音频隐写的题目，这个题目很简单用到一个工具叫silentEye，SilentEye是一个跨平台的应用程序设计，可以轻松地使用隐写术，在这种情况下，可以将消息隐藏到图片或声音中。它提供了一个很好的界面，并通过使用插件系统轻松集成了新的隐写算法和加密过程。 下载地址：http://www.opdown....
新标准日本语初下 课后练习作业 纯记录
qq_41490154的博客
04-26 1620
ーーああ、あの人ですか。何度か顔を見たことがあるんですが、名前はちょっと、、、（d）すみません、ちょっと、、、ーーああ、あの人ですか。一度会ったことがあるんですが、名前はちょっと、、、ーーああ、あの人ですか。一度話したことがあるんですが、名前はちょっと、、、ーーああ、あの人ですか。顔を見たことがあるんですが、名前はちょっと、、、ーーああ、あの人ですか。話したことがあるんですが、名前はちょっと、、、２　あなたが買いたいかばんはどれですか。５　（スミスさんと話している）人は陳さんではありません。
Python日常练习题
weixin_33841503的博客
04-25 520
第三天练习题： 开发敏感词过滤系统，提示用户输入内容，如果用户输入内容包含特殊的字符：eg：如苍井空，则将内容替换为＊＊＊ sensitive = ['东京热','苍井空','饭岛爱','小泽玛丽亚','大傻逼'] while True: word = str(input("请输入内容：>>")) for i in sensitive:...
【日常】python脚本系列：拳皇13一键出招以及连段实现
梦想破三的奔三狗
07-14 1万+
20200726更新
python 日常练习
weixin_41270708的博客
08-06 565
一、课前练习 1. 26个字母大小写成对打印，例如：Aa,Bb.... 2.一个list包含10个数字，然后生成新的list， 要求，新的list里面的数都比之前的数多1 3.倒序取出每个单词的第一个字母。 4 请大家找出s=”aabbccddxxxxffff”中，出现次数最多的字母   练习一：打印AaBbCcDd   算法： 1 定义一个字符串result存数据 2 拼接...
YOLO26一文弄懂 | YOLO26内容详解、网络结构解读 、yolo26.yaml配置文件详细解读与说明、YOLO26虚拟环境安装、模型训练、验证、推理参数详细解析 | 通俗易懂！入门必看系列！
Ai缝合怪、助力小伙伴高效发论文
01-15 1万+
YOLO26目标检测模型创新与应用指南 本文全面介绍了YOLO26目标检测模型的创新特性、网络结构及实践应用。YOLO26基于四大核心原则设计：简洁性（移除NMS后处理）、部署效率（端到端架构）、训练创新（MuSGD优化器）和任务优化（支持多种视觉任务）。模型包含五种尺寸规格，CPU推理速度提升43%，支持目标检测、实例分割、姿态估计等任务。 文章详细解析了YOLO26的网络结构（Backbone-Neck-Head三部分）和yaml配置文件，提供了从虚拟环境配置到模型训练、验证、推理的完整教程。
Ubuntu 20.04下Carla 0.9.13安装避坑指南
最新发布
lemon的博客
02-23 779
本文是一份针对Ubuntu 20.04系统安装Carla 0.9.13自动驾驶仿真平台的详细避坑指南。文章重点解决了显卡驱动配置、交换分区扩容、系统依赖安装、UE4.26编译以及Carla源码构建过程中的常见网络与版本兼容性问题，旨在帮助用户高效完成复杂环境的部署。
Oracle Linux 9上PostgreSQL 13.18二进制安装全流程（含systemd服务配置）
o1p2q3r的博客
02-20 568
本文详细介绍了在Oracle Linux 9上安装和优化PostgreSQL 13.18二进制文件的完整流程，包括系统适配、仓库配置、数据库初始化、systemd服务定制以及性能调优。通过逐步指导，帮助用户高效部署和配置PostgreSQL，确保系统兼容性和高性能运行。
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值