• 黑马Java第六讲—基本练习

    🎨 个人介绍

    👉大家好，我是：知识的搬运工旺仔

    👉认真分享技术，记录学习过程的点滴，如果我的分享能为你带来帮助，请支持我奥🍻

    👉你的支持，是我每天更新的动力。

    👉赞点：👍 留言：✍ 收藏：⭐

    👉个人格言：想法一步一步的落实，才是你我前进最佳选择。

    黑马Java第六讲—基本练习

    1. 减肥计划if版本

    1 ）需求

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

    2 ）思路

    1. 键盘录入一个星期数，用一个变量接收
    2. 对星期数进行判断，这里用if语句实现
    3. 在对应的语句控制中输出对应的减肥活动

    3 ）代码(if…else if)

    public static void main(String[] args) {
    //键盘录入一个星期数,用bl接收
    Scanner input = new Scanner(System.in);
​
    System.out.println("请输入一个星期数");
    int week = input.nextInt();
​
    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{
        System.out.println("好好吃一顿");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    4 ）代码（switch版本）

    public static void main(String[] args) {
        //键盘录入一个星期数,用bl接收
        Scanner input = new Scanner(System.in);
​
        System.out.println("请输入一个星期数");
        int week = input.nextInt();
​
        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("您输入的星期数有误");
                break;
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    2. 逢七过

    需求：朋友聚会的时候，可能会玩一个游戏逢七过。

    规则是：任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时，都要说：过

    为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据

    思路：

    1. 数据在1-100之间，用for循环实现数据的获取
    2. 根据规则，用if语句实现数据的判断：要么个位是7，要么，能够被7整除

    代码：

    public static void main(String[] args) {
    //数据在1-100之间，用for循环实现数据的获取
    for(int x = 1;x <=100;x++){
        //根据规则，用if语句
        if(x%10==7 || x%7==0||x/10%10==7) {
            System.out.println(x);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    3. 不死神兔

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

    找规律：其实就是斐波那契数列的规律

    思路：

    1. 为了储存多个月的兔子对数，定义一个数组，用动态初始化完成数组，长度为20；
    2. 因为第一个月，第二个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素也都是1
    3. 用循环实现计算每个月的兔子对数

    代码：

    public static void main(String[] args) {
    int[] rabbitArray = new int[20];
    rabbitArray[0] = 1;
    rabbitArray[1] = 1;
    for (int i = 2; i < rabbitArray.length; i++) {
        rabbitArray[i] = rabbitArray[i - 1] + rabbitArray[i - 2];
    }
    for (int x = 0; x < rabbitArray.length; x++) {
        System.out.println("兔子第" + (x + 1) + "月，的数目为：" +                   rabbitArray[x]);
    }
​
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    4. 百钱百鸡

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

    思路：

    1. 第一层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0,判断条件是x<=20
    2. 第二层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0,判断条件是x<=33
    3. 这个时候，用于表示鸡雏的变量z=100-x-y4
    4. 判断表达式z%3==0和表达式5 * x+3 * y+z/3 =100是否同时成立，如果成立，输出对应x,y,z的值，就是对应，鸡翁，鸡母，鸡雏的值

    代码

    public static void main(String[] args) {
        //第一层循环表示鸡翁的范围
        for (int x = 0; x <= 20; x++) {
            //第二层表示鸡母的范围
            for (int y = 0; y <= 33; y++) {
                //这是鸡雏的数量
                int z = 100 - x - y;
                if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
                    System.out.println("鸡翁："+x+"\t鸡母:"+y+"\t鸡雏："+z);
                }
            }
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    5. 数组元素求和

    需求：

    有这样的一个数组，元素是{68，27，95，88，171，996，51，210}。求出该数组中满足要求的元素和

    要求是：求和的元素个位和十位都不能是7，并且只能是偶数

    思路：

    1. 定义一个数组，用静态初始化完成数组元素初始化
    2. 定义一个求和变量，初始值是0
    3. 遍历数组，获取到数组中的每一个元素
    4. 判断该元素是否满足条件，如果满足条件就累加
    5. 输出求和变量

    代码

    public static void main(String[] args) {
    //定义一个数组，静态初始化
    int[] array = {68, 27, 95, 88, 171, 996, 51, 210};
​
    //定义一个求和变量
    int sum = 0;
​
    //遍历数组
    for (int x : array) {
        if (x % 10 != 7 && x / 10 % 10 != 7 && x % 2 == 0) {
            System.out.println("符合要求的数："+x);
            sum+=x;
        }
    }
    System.out.println("sum="+sum);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    6. 判断两个数组是否相同

    需求：

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

    思路：

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

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

    3. 比较相等，需要用到一下步骤

      • 首先比较数组的长度，如果长度不相等，数组内容肯定不相等，返回false
      • 其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
      • 最后循环遍历结束后，返回ture

    4. 调用方法，用变量接收

    5. 输出结果

    代码：

    public static void main(String[] args) {
    //首先定义两个数组
    int[] array1 = {11, 22, 33, 44};
    int[] array2 = {11, 22, 33, 44};
    boolean flag = compare(array1, array2);
    System.out.println("这两个数组是否相等："+flag);
}
​
public static boolean compare(int[] a, int[] b) {
    //首先比较数组长度
    if (a.length != b.length) {
        return false;
    }
​
    for (int i = 0; i < a.length; i++) {
        if (a[i] != b[i]) {
            return false;
        }
    }
    return true;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    7. 查找元素在数组中出现的索引位置

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

    思路：

    1. 定义一个数组，用静态初始化完成数组元素的初始化
    2. 键盘录入要查找的数据，用一个变量接收
    3. 定义一个索引变量，初始值为-1
    4. 遍历数组，获取到数组中的每一个元素
    5. 拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把值所对应的索引赋值给变量，并结束循环

    代码：

    public static void main(String[] args) {
    //定义一个数组
    int[] array = {19,28,37,46,50};
​
    //键盘录入要查找的数据
    Scanner input = new Scanner(System.in);
​
    System.out.println("输入要查找的数据：");
    int number = input.nextInt();
​
    //定义一个索引，初始化为-1
    int index = -1;
    //遍历数组
    for (int i = 0; i < array.length; i++) {
        if(array[i] ==number) {
            index = i;
            break;
        }
    }
    if(index == -1) {
        System.out.println("您输入的数字不在数组内");
    }else {
        //输出索引变量
        System.out.println("你输入的数字的索引是："+index);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    8. 数组元素反转

    需求：

    已知一个数组array = {19,28,97,46,50};用程序实现把数组中方的元素值交换

    交换后的数组array = {50，46，97，28，19} ；在控制台输出

    思路：

    1. 定义一个数组，用静态初始化完成数组元素的初始化
    2. 循环遍历数组，这一次初始化语句两个索引变量，判断条件时开始索引小于等于结束索引
    3. 变量交换
    public static void main(String[] args) {
    int[] array = {19,28,37,46,50};
    reverse(array);
    printArray(array);
}
/**
        让数组元素反转的代码
 */
public static void reverse(int[] array) {
    for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
    }
}
​
/**
       遍历数组的方法
      */
public static void printArray (int[] array) {
    for(int a : array) {
        System.out.print("数组反转后的元素为：");
        System.out.println(a+"\t");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    9. 评委打分

    需求：

    在编程竞赛中，有6各评委为参赛者选手打分，分数为0-100的整数

    选手的最后得分为，去掉一个最高分，和一个最低分后的4个评委平均值

    思路：

    1. 定义一个数组，用动态初始化完成数组元素的初始化，长度为6
    2. 键盘录入6个评委打分，所以，接收评委分数的操作，同循环改进
    3. 由于是6个评委打分，所以，接收评委分数的操作，用循环改进
    4. 定义方法实现获取数组中的最高分，调用方法
    5. 定义方法实现获取数组中的最低分，调用方法
    6. 定义方法实现获取数组中的所有元素的和，调用方法
    7. 按照规则进行计算得到平均数

    代码：

    public static void main(String[] args) {

    int[] array = new int[6];

    inputNumberByArray(array);
    int average = averageValue(array);
    System.out.println("平均分数为："+average);
}
/*
        实现给数组元素录入值
    */

public static void inputNumberByArray(int[] array) {
    Scanner input = new Scanner(System.in);

    for (int i = 0; i < array.length; i++) {
        System.out.println("请输入第" + (i + 1) + "个值");
        array[i] = input.nextInt();
    }
}

/*
        找出数组的最大值
    */

public static int getMaxByArray(int[] array) {
    int max = array[0];
    for (int j : array) {
        if (j > max) {
            max = j;
        }
    }
    return max;
}

/*
        找出数组的最小值
    */

public static int getMinByArray(int[] array) {
    int min = array[0];
    for (int j : array) {
        if (j < min) {
            min = j;
        }
    }
    return min;
}

/*
    求出数组的总和
    */

public static int getSumByArray(int[] array) {
    int sum = 0;
    for (int a : array) {
        sum += a;
    }

    return sum;
}

/*
    计算平均值
    */

public static int averageValue(int[] array) {
    int average;
    int min = getMinByArray(array);
    int max = getMaxByArray(array);
    int sum = getSumByArray(array);
    average = (sum - max - min) / 4;
    return average;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74

    🎈看完了不妨给我点个赞吧，👉你的支持，是我每天更新的动力…

  • 相关阅读:
    保姆式教你如何用navicat导入Excel文件到MySQL数据库实操
    SpringBoot全局异常配置
    五年Python从业者，谈谈Python的一些优缺点
    【web-攻击验证机制】（3.4.2）保障验证机制的安全：防止蛮力攻击、防止滥用密码修改、账户恢复功能、日志、监控与通知
    git修改默认分支
    postgreSQL中的高速缓存
    【数学篇】08 # 如何利用三角剖分和向量操作描述并处理多边形？
    阿里云在云原生领域喜获多项 OSCAR 开源尖峰案例奖
    MySQL - Explain详解
    如何快速清理c盘缓存垃圾（最简单的c盘清理方法）
  • 原文地址：https://blog.csdn.net/weixin_46213083/article/details/126492844