Java语法之基础题目练习(一)

1、减肥计划
需求:输入星期数,显示今天得到减肥活动
周一;跑步
周二:游泳
周三:慢走
周四:动感单车
周五:拳击
周六:爬山
周日:好好吃一顿

package com.Test;
import java.util.Scanner;
//减肥计划,采用Switch语句实现
    思路:
        ①键盘录入一个星期数,用一个变量接收
        ②对星期数进行判断,用Switch语句实现
        ③在对应的语句控制中输出对应的减肥活动
    导包*/
public class Test01 {
    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("你输入的星期数有误");
        }
    }
}

2、逢七必过游戏
从任意一个数字开始报数,当所要报的数字含7或者是7的倍数时都要说:过,在这里我们在控制台打印出1-100之间满足逢七必过规则的数据。

package com.Test;
/* 逢七必过游戏
  * 思路:
  *     ①数据在1-100之间,用for循环实现数据的获取
  *     ②根据规则,用if语句实现数据的判断,要么个位是7,要么十位是7,要么能够被7整除
  *      x%10==7    x/10%10==7   x%7==0
  *     ③在控制台输出满足需求的数据*/
public class Test02 {
    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);
            }
        }
    }
}

3、不死神兔
需求:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问第二十个月兔子数为多少?

package com.Test;
/*不死神兔
*     规律:
*         第一个月:1
*         第二个月:1
*         第三个月:2
*         第四个月:3
*         第五个月:5
*         第六个月:8
*         。。。
*     用数组模拟:
*          arr[0]=1;
*          arr[1]=1;
*          arr[2]=arr[0]+arr[1];
*          arr[3]=arr[1]+arr[2];
*     思路:
*          ①定义一个数组,存储多个月的兔子对数,用动态初始化完成数组元素的初始化,长度为20
*          ②因为第一个月,第二个月兔子的对数是已知的,都是1,数组第一个元素,第二个元素值也都是1
*          ③用循环实现计算每个月兔子的对数
*          ④控制台输出最后一个元素值,即第20个月的兔子对数
* */
public class Test03 {
    public static void main(String[] args) {
        int[] arr=new int[20];
        arr[0]=1;
        arr[1]=1;
        for(int x=2;x<arr.length;x++){
            arr[x] = arr[x-2] + arr[x-1];
        }
        System.out.println("第20个月兔子的对数是:"+arr[19]);
    }
}

4、百钱百鸡
鸡翁一值钱五,鸡母一值钱三,鸡雏三值钱一,百钱买百鸡,问鸡翁,鸡母,鸡雏,各几何?

package com.Test;
//百钱百鸡
/*
   鸡翁一值钱五,鸡母一值钱三,鸡雏三值钱一,百钱买百鸡,问鸡翁,鸡母,鸡雏,各几何?
    分析:
       设鸡翁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,判断条件是X<=33
       ③第三层循环,表示鸡雏的范围,z=100-x-y
       ④判断表达式z%3==0和表达式5*x+3*y+z/3==100是否同时成立,如果成立,输出对应的x,y,z的值。

       */
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;
                if (z%3==0 && 5*x+3*y+z/3==100){
                    System.out.println("鸡翁"+x+",鸡母"+y+"鸡雏,"+z);
                }
            }
        }
    }
}

5、数组元素求和
需求:
存在一数组,元素是{68,37,95,88,173,996,53,310},求出该数组中满足要求的元素 和,
要求是:求和的元素个位和十位都不能是7,并且只能是偶数

package com.Test;
//数组元素求和
/*
  思路:
      1、定义数组,静态初始化完成数组的初始化
      2、定义一个求和变量,初始值为0
      3、遍历数组,获取到数组的每一个元素
      4、判断该元素是否满足条件,如果满足条件就累加
        arr[x]%10!=7    arr[x]/10%10!=7       arr[x]%2 == 0
      5、输出求和变量的值*/

public class Test05 {
    public static void main(String[] args) {
        int[] arr = {68,27,95,88,171,996,51,210};
        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);
    }
}

6、设计一个方法,比较两个数组内容是否相同

package com.Test;
//设计一个方法,比较两个数组内容是否相同
/*
   思路:
       1、定义两个数组,分别使用静态初始化完成数组元素的初始化
       2、定义一个方法,用于比较两个数组的内容是否相同
            返回值类型:Boolean
            参数:int[] arr,int[] arr2
       3、比较两个数组的内容是否相同,按照以下步骤实现
         首先比较数组长度,如果长度不相同,数组内容肯定不相同,返回false
         其次遍历,比较两个数组中的每一个元素,只要有元素不相同,返回false
         最后循环遍历结束后,返回true

       4、调用方法用变量接收
       5、输出结果*/
public class Test06 {
    public static void main(String[] args) {
//        1、定义两个数组,分别使用静态初始化完成数组元素的初始化
        int[] arr = {11,22,33,44,55};
        int[] arr2 = {11,22,33,44,55};
//        调用方法用变量接收
        boolean flag = compare(arr,arr2);
        System.out.println(flag);
    }
    /* 2、定义一个方法,用于比较两个数组的内容是否相同
     返回值类型: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;
    }
}

7、查找
已知一个数组,键盘录入数据,查找该数据在数组中的索引,在控制台输出索引值。
分析:
假如录入一个数组不存在的数据,就会没有任何输出,在实际开发中,如果对应索引不存在,我们通常返回一个负数,用-1来表示。

package com.Test;

import java.util.Scanner;

//查找
/*
    思路:
       1、定义一个数组,用静态初始化完成数组元素的初始化
       2、键盘录入要查找的数据,用一个变量接收
       3、定义一个索引变量,初始值为-1
       4、遍历数组,获取到数组中的每一个元素
       5、将键盘录入数据与数组中每一个元素做比较,如果值相同,就把该值对应的索引赋值
       给索引变量,并结束循环
       6、输出索引变量*/
public class Test07 {
    public static void main(String[] args) {
//        1、定义一个数组,用静态初始化完成数组元素的初始化
        int[] arr={12,22,66,58,69};
//        2、键盘录入要查找的数据,用一个变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的数:");
        int number = sc.nextInt();


      /*  程序优化,将此处代码定义为一个方法
      //        3、定义一个索引变量,初始值为-1
      int index = -1;
//        4、遍历数组,获取到数组中的每一个元素
        for (int x=0;x<arr.length;x++){
            *//* 5、将键盘录入数据与数组中每一个元素做比较,如果值相同,就把该值对应的索引赋值
            给索引变量,并结束循环*//*
            if (arr[x] == number){
                index = x;
                break;
            }
        }*/
//        调用方法
        int index=getIndex(arr,number);
//        6、输出索引变量
        System.out.println("index:"+index);
    }
//    查找指定的数据在数组中的索引
    /*
    两个明确:
         返回值类型:int
         参数:int[] arr,int number
         */
    public static int getIndex(int[] arr,int number){
        int index = -1;
//        4、遍历数组,获取到数组中的每一个元素
        for (int x=0;x<arr.length;x++){
            /* 5、将键盘录入数据与数组中每一个元素做比较,如果值相同,就把该值对应的索引赋值
            给索引变量,并结束循环*/
            if (arr[x] == number){
                index = x;
                break;
            }
        }
        return index;
    }
}

8、反转
将数组元素顺序颠倒

package com.Test;
//反转
/*
   思路:
       1、定义一个数组,用静态初始化完成数组元素的初始化
       2、循环遍历数组,这一次初始化语句定义两个索引变量,判断条件是开始索引小于等于结束索引
       3、变量交换
       4、遍历数组*/
public class Test08 {
    public static void main(String[] args) {
//        1、定义一个数组,用静态初始化完成数组元素的初始化
        int[] arr = {12, 23, 34, 45, 56, 67};
        /*将此处代码定义为一个方法
        for(int start=0,end=arr.length-1;start<=end;start++,end--){
            int temp=arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
        }
        */
//        调用反转方法
        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.print("]");
    }
}

9、评委打分
需求:
在编程竞赛中,有6个评委为参赛的选手打分,分数为0-100的整数分。
选手的最后得分为:去掉一个最高分和一个最低分后的4个评委的平均值(不考虑小数部分)

package com.Test;
import java.util.Scanner;
//评委打分
/*  
   思路:
     1、定义一个数组,用动态初始化完成数组元素的初始化,长度为6
     2、键盘录入评委分数
     3、由于是6个评委打分,所以,接收评委分数的操作,用循环改进
     4、定义方法实现获取数组中的最高分(数组最大值),调用方法
     5、定义方法实现获取数组中的最低分(数组最小值)、,调用方法
     6、定义方法实现获取数组中的所有元素的和(调用方法)
     7、按照计算规则进行计算得到平均分
     8、输出平均分
   */
public class Test09 {
    public static void main(String[] args) {
        int[] arr = new int[6];
        Scanner sc = new Scanner(System.in);
        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 getMax(int[] arr){
        int max=arr[0];
        for (int x=1;x<arr.length;x++){
            if (arr[x]>max){
                max=arr[x];
            }
        }
        return max;
    }
    //定义方法实现获取数组中的最低分
     /*
      两个明确:
         返回值类型:int
         参数: int[] arr
         */
     public static int getMin(int[] arr){
         int min = arr[0];
         for (int x=1;x<arr.length;x++){
             if (min>arr[x]){
                 min = arr[x];
             }
         }
         return min;
     }
     /*
     定义方法获取数组中所有元素的和(数组元素求和)
     两个明确:
        返回值类型;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;
     }
     //遍历数组
    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.print("]");
    }
}

已标记关键词 清除标记
相关推荐