java综合练习

学习目标：

• 综合练习
• 在IDEA中使用Debug

---

学习内容：

1.

if语句

/*通过键盘录入的方式输入星期数(1-7的整数)，显示今天的减肥活动，使用switch和if两种判断语句分别完成。（可写成2个方法）
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿*/
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入星期数：");
        int week=sc.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-7的范围，不满足输出有误
之后根据输入的周几，if…elseif进行周几对应的活动输出。
Debug
鼠标左键在这行代码添加断点

区域鼠标右键Debug，输入5回车，按下f7查看程序执行过程，当week==5为true时，执行输出拳击

switch语句
switch思路差不多，记得每次输出结果后加break，跳出循环。

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("你输入的星期数有误");
        }

2.

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

public class Test02 {
    public static void main(String[] args) {
        for(int i=1;i<=100;i++){//1-100
            if(i%7==0 || i%10==7 || i/10%10==7){//满足7的倍数，个位是7，十位是7
                System.out.println(i);
            }
        }
    }
}

思路：
for循环确定1-100的范围，if语句判断包含7或者是7的倍数，换句话说，也就是个位、十位含7，能够被7整除的数都在其中，满足条件则输出。

3.

/*有一个很有名的数学逻辑题叫做不死神兔问题。
有一对兔子，从出生后第3个月起每个月都生一对兔子，
小兔子长到第三个月后每个月又生一对兔子，
假如兔子都不死，问第二十个月的兔子对数为多少？*/

public class Test03 {
    public static void main(String[] args) {
       int[] a=new int[20];//定义长度为20的数组
       a[0]=1;//第1个月1对
       a[1]=1;//第2个月1对
       for(int i=2;i<a.length;i++){
        a[i]=a[i-2]+a[i-1];//假设推出规律
       }
        System.out.println("第二十个月的兔子对数为"+a[19]);
    }
}

思路：
1）首先用假设法推算得出之后几个月的数据，可以得到以下的规律

由图可以推出，从第3个月开始的兔子对数等于上个月和上上个月的兔子对数之和。因为要一次性声明大量的相同数据类型的变量，我们可以定义一个数组来存储兔子对数，长度为20。
2）for循环得到每个月的兔子对数，最后输出a[19]也就是第20个月的兔子对数。

4.

/*我国古代数学家张丘建在《算经》中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？*/
public class Test04 {
    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;//大概估值，给出一个小鸡的变量表达式
             //满足能够被3整除，并且总共花了一百元
             if(z%3==0 && 5*x+3*y+z/3==100){
                 System.out.println("鸡翁"+x+"鸡母"+y+"鸡雏"+z);
             }
         }
     }
    }
}

思路：
1）作为一个数学题，本题的难点在于给出公鸡母鸡小鸡的大致数量范围，用一百去除以公鸡和母鸡的价格，得到范围，可以大致确定小鸡的范围z=100-x-y；
2）百钱买百鸡，循环中if判断总的三种鸡数量的价格是否等于一百，还有题目中3只小鸡值1元，小鸡数量不可以约等，所以还要加上小鸡的数量必须满足能够被3整除的条件。

5.

/*有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和，
要求是：求和的元素个位和十位都不能是7，并且只能是偶数。*/
public class Test05 {
    public static void main(String[] args) {
        int[] a={68,27,95,88,171,996,51,210};
        int sum=0;
        for(int i=0;i<a.length;i++){
         if(a[i]%10!=7 && a[i]/10%10!=7 && a[i]%2==0){//判断求和的元素个位和十位都不能是7，并且只能是偶数
                sum+=a[i];//求和
            }
        }
        System.out.println("满足要求的元素和："+sum);
    }
}

6.

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

public class HelloWorld {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,3,2,1};
        int[] arr2 = {1,2,3,4,3,2,1};
        System.out.println(" 是否一致:" +equals(arr ,arr2) );//调用输出

    }
    //  比较
    public static boolean equals(int[] arr1, int[] arr2) {
        // 长度不同,返回false
        if (arr1.length != arr2.length) {
            return false;
        }// arr1[i] 和 arr2[i]比较
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }
}

思路：
1）定义一个boolean型的方法，进行两个数组的比较，数组完全一致要满足长度一致，数组的值一致，以及值内存地址一致。
2）方法定义中，如果两个数组同个位置的元素不相等返回false值，否则返回true。
3）方法调用equals(arr ,arr2) 。

7.

/*已知一个数组 arr = {19, 28, 37, 46, 50};
键盘录入一个数据。
定义一个方法，完成查找该数据在数组中的索引，并在控制台输出找到的索引值。*/
import java.util.Scanner;
public class Test07 {
    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();//接受输入的数据
        int index=getIndex(arr,number);//方法调用
        System.out.println("索引:"+index);
    }

    public static int getIndex(int[] arr,int number){
        int index=-1;//定义索引的初始值
        for(int i=0;i<arr.length;i++){
            if(arr[i]==number){//遍历找到这个数的索引
                index=i;
                break;//找到索引退出循环
            }
        }
        return index;//返回索引值
    }
}

思路：
1）定义数组和输入的数据，然后进行方法的定义，要找到数据在这个数组中的索引，定义该方法为int型，参数为数组和要查找的数。
2）在方法中定义索引的初始值为-1，遍历查找arr[i]=number，找到就退出循环，返回索引值。
3）在主方法中，定义索引调用索引查找的方法，最后打印输出索引。

8.

/*
已知一个数组 arr = {19, 28, 37, 46, 50};
用程序实现把数组中的元素值反转(在原数组中操作，不能定义第二个数组)，
反转后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出反转后的数组元素。
*/
import java.util.Arrays;
public class Test08 {
    public static void main(String[] args) {
        int[] arr={19, 28, 37, 46, 50};//定义数组
        for(int i=0;i<arr.length/2;i++){//交换arr.length/2次位置
            int temp=arr[arr.length-i-1];
            arr[arr.length-i-1]=arr[i];
            arr[i]=temp;
        }//强制输出数组的全部元素
        System.out.print(Arrays.toString(arr));
    }
}

思路：
1）定义数组，for循环进行arr.length/2次交换位置，交换完毕打印输出。

9.

/*在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。*/
import java.util.Scanner;
public class Test09 {
    public static void main(String[] args) {
        int[] a=new int[6];//定义长度为6的数组
        Scanner sc=new Scanner(System.in);
        //逐个输入评委分数并且赋值给数组
        for(int i=0;i<a.length;i++){
            System.out.print("输入第"+(i+1)+"个评委的评分：");
            a[i]=sc.nextInt();
        }
        //调用方法得到最小值最大值和总分
        int max=getMax(a);
        int min=getMin(a);
        int sum=getSum(a);
        int avg=(sum-max-min)/4;
        System.out.println("平均分"+avg);

    }
    //定义总分方法
    public static int getSum(int[] a){
        int sum=0;
        for(int i=0;i<a.length;i++){
            sum+=a[i];
        }
        return sum;
    }
    //定义最小值方法
    public static int getMin(int[] a){
        int min=a[0];
        for(int i=0;i<a.length;i++){
            if(a[i]<min){
                min=a[i];
            }
        }
        return min;
    }
    //定义最大值方法
    public static int getMax(int[] a){
        int max=0;
        for(int i=0;i<a.length;i++){
            if(a[i]>max){
                max=a[i];
            }
        }
        return max;
    }

}

思路：
1）学了方法之后，可以用方法定义和调用解决这个问题。首先定义数组，键盘逐个输入分数并赋值给数组，优化了之前的代码。
2）要得到最大值最小值和总分，都需要遍历，全在主方法中实现，逻辑不太清晰。因此，我们分别定义三个方法，遍历得到它们的值，这里要注意定义方法选择的是带返回值的方法，所以需要return得到的分数。
3）在主方法中声明调用方法得到最大值最小值和总分，再用表达式得到平均分，最后打印输出。

10.

/编写程序实现对给定的 4 个整数从大到小的顺序排列。
import java.util.Scanner;
import java.util.Arrays;
public class Work01 {
    public static void main(String[] args) {
        int[] a = new int[4];//定义长度为4的数组
        Scanner sc=new Scanner(System.in);
        //输入4个数并把它们赋值给数组
        for(int i=0;i<a.length;i++){
            System.out.println("输入第"+(i+1)+"个整数:");
            a[i]=sc.nextInt();
        }
        Sort(a);//方法调用
        System.out.println(Arrays.toString(a));//强制输出
    }
    public static void Sort(int[] a){
        //冒泡排序交换位置
        for(int i=0;i<a.length-1;i++){//因为从0开始，次数减一
            for(int j=0;j<a.length-1-i;j++){//减去已经排好i个数
                if(a[j]<a[j+1]) {//从大到小
                    int temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;//交换完毕
                }
            }
        }
    }
}

思路：
1）定义长度为4的数组，for循环输入4个整数并把它们赋值给数组。
2）方法定义，用冒泡排序排好，不符合从大到小的顺序，就将相邻的数交换位置，直到循环结束。
3）方法调用，打印输出排好顺序的数组。

这是选择排序，使用Deubug可以看到和冒泡的区别

 public static void Sort(int[] a){
        //选择排序交换位置
        for(int i=0;i<a.length-1;i++){//已排序
            for(int j=i+1;j<a.length;j++){//未排序
                if(a[j]>a[i]) {//从大到小
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;//交换完毕
                }
            }
        }
    }

思路：
1）选择排序，找到数组中最小的一个数，和第一个数交换位置，在还没有排序的剩下数中再找到一个最小值，和第二个数交换位置，以此类推，直到结束循环。

11.

 import java.util.Scanner;
// 输入 3 个正数，判断能否构成一个三角形。Triangle
public class Work02 {
    public static void main(String[] args) {
      int[] a= new int[3];
        Scanner sc=new Scanner(System.in);
        //输入3个数并把它们赋值给数组
        for(int i=0;i<a.length;i++){
            System.out.println("输入第"+(i+1)+"个整数:");
            a[i]=sc.nextInt();
        }
        System.out.println("是否构成三角形"+Triangle(a));
    }

    public static boolean Triangle(int[] a){
        if(a[0]+a[1]>a[2] && a[0]+a[2]>a[1] && a[2]+a[1]>a[0]){//任意两边之和大于第三边
            return true;
        }else{
            return false;
        }
    }
}

思路：
1）for循环存储输入的三角形三条边。
2）定义一个boolean型方法，满足任意两边之和大于第三边，那么这组数就能构成三角形。
3）打印输出，调用三角形方法。

12.

/*编写程序，从键盘输入一个 0~99999 之间的任意数，
判断输入的数是几位数？*/
import java.util.Scanner;
public class Work03 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);//创建输入对象
        System.out.println("请输入0-99999的一个任意整数：");
        int a = sc.nextInt();
        Count(a);//调用判断几位数
    }

    public static void Count(int a){
        if(a/10000>=1){//判断输出
            System.out.println("五位数");
        }else if(a/1000>=1){
            System.out.println("四位数");
        }else if(a/100>=1){
            System.out.println("三位数");
        }else if(a/10>=1){
            System.out.println("两位数");
        }else{
            System.out.println("一位数");
        }
    }
}

思路;
定义判断0-99999范围内这个任意数是几位数的方法，不用返回值，发现规律从判断五位数开始，从上到下，如果不能被10000除后大于等于1，那就往下是否能被1000除后大于等于1，依次往下，直到符合条件，直接输出这个数是几位数。

13.

/*编写程序，给定一个学生成绩，给出相应等级：
（要求：请用方法实现，传入成绩参数，返回等级打印）
90~100 优秀
80~89 良好
70~79 中等
60~69 及格
0~59 不及格*/
import java.util.Scanner;
public class Work04 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("输入成绩：");
        int score=sc.nextInt();//键盘输入成绩
        getGrade(score);
    }
    public static void getGrade(int score){
        if(score>=90&&score<=100){//判断成绩等级
            System.out.println("成绩优秀");
        }else if(score>=80&&score<=89){
            System.out.println("成绩良好");
        }else if(score>=70&&score<=79){
            System.out.println("成绩中等");
        }else if(score>=60&&score<=69){
            System.out.println("成绩及格");
        }else{
            System.out.println("成绩不及格");
        }
    }
}

思路：
1）定义方法，传入成绩参数，判断等级后，打印输出成绩等级。
2）键盘输入给定的成绩，调用得到成绩的方法，得到结果。

14.

/*验证“鬼谷猜想”：
对任意自然数，若是奇数，就对它乘以 3 再加 1；
若是 偶数，就对它除以 2，这样得到一个新数，
再按上述计算规则进行计算，一直进行下去，最终必然得到 1。（1--1000）*/
import java.util.Scanner;
public class Work05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个1-1000的数");
        int number = sc.nextInt();
        //键盘输入
        for (int i = 1; i <= 1000; i++) {
            if(number%2!=0){//奇数的情况
                number=number*3+1;
            }else{//偶数
                number=number/2;
            }
            if (number==1){//最后等于1的话，验证成功
                System.out.println("鬼谷猜想验证成功！");
                break;
            }
        }
    }
}

思路：
1）给出一个1-1000的数，在循环当中，对它进行判断，第一个if语句判断奇数偶数，得到的数用第二个if语句进行判断，是否等于1，不等于就再接着进行判断，直到得到的数等于1，那就证明鬼谷猜想验证成功。

15.

/*某公司每月标准上班时间是160小时，每小时工资是30元。
如果上班时间超出了160小时，超出部分每小时按1.5倍工资发放。
请编写程序计算员工月工资。（请用方法实现）*/
import java.util.Scanner;
public class Work06 {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入月上班时长：");
        int hour=sc.nextInt();
        //键盘输入时长
        getSalary(hour);
    }
    public static void getSalary (int hour){
        int salary=0;//定义工资初始值为0
        if(hour<160){//根据时长，计算工资高并打印输出
            System.out.println("上班时长达不到标准");
        }else if(hour==160){
            salary=hour*30;
            System.out.println("发放工资"+salary);
        }else{
            salary=(hour-160)*45+4800;
            System.out.println("发放工资"+salary);
        }
    }
}

思路：
1）员工的月薪决定于他的工作时长，首先键盘输入员工的工作时长。
2）定义不带返回值的方法，对传入的时长参数进行if判断，根据是否达到或者超出标准时长，打印输出工资。
3）在主方法中调用方法，实现月工资的计算并输出。

16.

/*求s=a+aa+aaa+aaaa+aa...a的值，
其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，
几个数相加由用户控制。*/
import java.util.Scanner;
public class Work07 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个个位数：");
        int a=sc.nextInt();
        System.out.println("请输入几个数相加：");
        int b=sc.nextInt();//键盘输入
        int n=a;//缓存尾数？
        int sum=0;
        for(int i=0;i<b;i++){//进行a+aa+aaa+a...a的计算
            sum+=a;//求和
            a*=10;//向左移位
            a+=n;//加上位数
        }
        System.out.println("和为"+sum);//输出和
    }
}

思路：
1）键盘输入数和几个数相加
2）要把每次构成的数相加b次，每次构成的数方法是，先求和，每次循环都把新构成的数叠加，之后要实现aaa这样的形式的数，每次乘以10，让a向左移位，然后把这个数加上他本身，也就是尾数。
3）这样随着循环次数叠加，就能出现如题a+aa+aaa+aaaa+aa…a这样形式的式子，最后打印输出sum。

17.

/*题目：一球从100米高度自由落下，
每次落地后反跳回原高度的一半；再落下，
求它在第10次落地时，共经过多少米？第10次反弹多高？  (利用方法)*/
public class Work08 {
    public static void main(String[] args) {
        getHeight();
    }
    public static void getHeight(){
        double sum = 0;
        double height = 100;
        for(int i = 1;i<=10;i++){
            sum = height+height/2+sum;//一次落地距离+弹起距离+已经过路程
            height/=2;//弹起高度为一半
        }
        sum-=height;
        //第10次落地经过路程需减去第10次弹起距离
        System.out.println("共经过"+sum+"米");
        System.out.println("第10次弹起的高度为："+height);
    }
}

思路：
1）首先球每次落地后都会反弹落下高度的一半，那么就用for循环实现，每次经过的路程=这次的落地距离加上弹起的距离（落地距离的一半），再加上前几次的距离。每次反弹的距离会随着循环次数减半。
2）因为要计算第10次经过的路程，每一次都是叠加了相应的弹起距离，这里以球落地为准，所以要减去第10次弹起的距离，最后打印输出经过的米数和弹起距离。