java 练习题

时间：2020-05-20 12:56:21 阅读：51 评论：0 收藏：0 [点我收藏+]

减肥计划if版本

需求：输入星期数[1,7]，显示今天的减肥活动

周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿

实现步骤:

创建键盘录入Scanner类的对象
获取键盘录入的1-7的整数数字(代表星期数),保存到int变量week中
因为week中的数字有7+1种情况,所以使用if语句的第三种格式对week中的数据进行判断,并输出不同的结果

public class IfJF {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

        //2.获取键盘录入的1-7的整数数字(代表星期数),保存到int变量week中
        System.out.println("请输入一个1-7的整数数字(代表星期数):");
        int week = sc.nextInt();

        //3.因为week中的数字有7+1种情况,所以使用if语句的第三种格式对week中的数据进行判断,并输出不同的结果
        //先判断无效数字
        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("好好吃一顿");
        }
        System.out.println("main....end...");
    }
}

减肥计划switch版本

public class SwitchJF {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

        //2.获取键盘录入的1-7的整数数字(代表星期数),保存到int变量week中
        System.out.println("请输入一个1-7的整数数字(代表星期数):");
        int week = sc.nextInt();

        //3.因为week中的数字有7+1种情况,所以使用switch语句对week中的数据进行判断,并输出不同的结果
        switch (week) {//5
            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;
        }
        System.out.println("main...end....");
    }
}

逢七跳过

需求：

在控制台打印出1-100之间的满足逢七必过规则(数字包含7或者是7的倍数) 的数据,以及总个数。
逢七必过规则(数字num包含7或者是7的倍数): (个位==7 或者十位==7) 或者 (num%7==0)

实现步骤：

定义int变量count,初始值0,用来统计满足逢七过规则的数据
使用for循环获取1-100之间的数字,循环变量int类型num
1. 计算当前num中数字的个位和十位,分别保存到int变量ge和shi中
2. 如果个位等于 7 或者十位等于 7 或者 num中的数字是7的倍数
  1. 打印num中的数字
  2. 计数器count的值增加1
  3. 循环结束打印count的值

public class FQG {
    public static void main(String[] args) {
        //定义int变量count,初始值0,用来统计满足逢七过规则的数据
        int count = 0;

        //使用for循环获取1-100之间的数字,循环变量int类型num
        for (int num = 1; num <= 100; num++) {
            //计算当前num中数字的个位和十位,分别保存到int变量ge和shi中
            int ge = num % 10;//个位
            int shi = num / 10 % 10;//十位

            //如果 个位 等于 7 或者 十位 等于 7 或者 num中的数字是7的倍数
            if ((ge==7 || shi==7) || (num%7==0)) {
                //打印num中的数字
                System.out.println(num);

                //计数器count的值增加1
                count++;
            }
        }
        //循环结束打印count的值
        System.out.println("符合逢七过的数字总共有: "+count+" 个");
    }
}

数组元素求和

需求：

有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。打印该数组中满足要求的元素和以及总个数
要求是：求和的元素个位和十位都不能是7，并且只能是偶数 (ge!=7 && shi!=7) && (array[i]%2==0)

实现步骤：

定义int变量count,初始值0,用来统计满足条件的数据的数量
定义int数组array,并按照题目要求进行初始化
使用for循环遍历数组
1. 计算当前元素的个位和十位,分别保存到int变量ge和shi中
2. 判断如果个位是 7 并且十位是 7 并且当前元素是偶数
  1. 打印当前元素值
  2. 计数器count的值增加1
  3. 循环结束后,打印count的值

public class Array {
    public static void main(String[] args) {
        int count = 0;
        int[] array = {68,27,95,88,171,996,51,210};

        //3.使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //计算当前元素的个位和十位,分别保存到int变量ge和shi中
            int ge = array[i]%10;//个位
            int shi = array[i] / 10 % 10;//十位

            //判断如果 个位 不是 7 并且 十位 不是 7  并且 当前元素是偶数
            if ((ge != 7 && shi != 7) && (array[i] % 2 == 0)) {
                //打印当前元素值
                System.out.println(array[i]);

                //计数器count的值增加1
                count++;
            }
        }
        //循环结束后,打印count的值
        System.out.println("满足条件的元素数量: "+count);
    }
}

数组统计学生成绩

需求：

键盘录入班级人数
根据录入的班级人数创建数组
利用随机数产生0-100的成绩(包含0和100)

要求：

打印该班级的不及格人数
打印该班级所有学生的平均分
演示格式如下:
- 请输入班级人数:
- 键盘录入:100
- 控制台输出:
- 不及格人数:19
- 班级平均分:87

实现步骤：

创建键盘录入Scanner类的对象
创建产生随机数的Random类的对象
获取键盘录入的整数数字(代表班级人数), 保存到int变量size中
创建长度为size的int数组array,只能采用动态初始化方式创建数组
按照要求产生size个随机数字,存储到数组array中
打印数组array中的元素(目的: 看数组中有没有存储对应的随机数字)
定义int变量count,初始值0,用来统计不及格人数
定义int变量sum,初始值0,用来统计所有学生的成绩之和
使用for循环遍历数组
1. 把当前元素累加到求和变量sum中
2. 如果当前元素值小于 60 计数器count的值增加1
for循环结束后,根据总分sum计算出平均分,保存到int变量avg中
打印count和avg的值

public class Score {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();

        //获取键盘录入的整数数字(代表班级人数), 保存到int变量size中
        System.out.println("请输入班级人数(整数数字):");
        int size = sc.nextInt();

        //创建长度为size的int数组array,只能采用动态初始化方式创建数组
        int[] array = new int[size];

        //按照要求产生size个随机数字,存储到数组array
        for (int i = 0; i < array.length; i++) {
            array[i] = r.nextInt(101);
        }

        //打印数组array中的元素(目的: 看数组中有没有存储对应的随机数字)
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("---------------");

        //定义int变量count,初始值0,用来统计不及格人数
        int count = 0;

        //定义int变量sum,初始值0,用来统计所有学生的成绩之和
        int sum = 0;

        //使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //把当前元素累加到求和变量sum中
            sum += array[i];

            //如果当前元素值 小于 60 计数器count的值增加1
            if (array[i] < 60) {
                count++;
            }
        }
        //for循环结束后,根据总分sum计算出平均分,保存到int变量avg中
        int avg = sum / (array.length);

        //打印count和avg的值
        System.out.println("不及格人数:" + count);
        System.out.println("班级平均分:" + avg);
    }
}

查找元素在数组中第一次出现的索引位置

需求(不定义方法)：

已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。
并在控制台输出找到的索引值。如果没有查找到，则输出-1

实现步骤：

1.定义int数组array,并初始化
2.创建键盘录入Scanner类的对象
3.获取键盘录入的整数数字(要查找的数字),保存到int变量value中
4.定义int变量index,初始值-1,作用保存找到的元素的索引值
5.使用for循环遍历数组
1. 如果当前元素值等于要查找的元素value
2. 把当前元素的索引值赋值给 index 结束循环break
循环结束直接打印变量index的值

public class GetValue {
    public static void main(String[] args) {
        int[] array = {19, 28,37, 46, 50};
        Scanner sc = new Scanner(System.in);

        // 获取键盘录入的整数数字(要查找的数字),保存到int变量value中
        System.out.println("请输入您要查找的元素(整数数字): ");
        int value = sc.nextInt();

        // 定义int变量index,初始值-1,作用保存找到的元素的索引值
        int index = -1;

        // 使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            // 如果当前元素值 等于 要查找的元素value
            if (array[i] == value) {
                // 把当前元素的索引值 赋值 给 index 结束循环break
                index = i;
                break;
            }
        }
        // 循环结束直接打印变量index的值
        System.out.println("元素值"+value+"在数组中的索引值: "+index);
    }
}

案例需求(定义方法)：

已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。
并在控制台输出找到的索引值。如果没有查找到，则输出-1

实现步骤：定义方法,获取一个int数据,在int数组中第一次出现的索引值,如果没有出现返回-1

三要素：

方法名称: getIndex
参数列表: int[] array,int value
返回值类型: int

getIndex方法的实现步骤：

定义int变量index,初始值-1,作用保存找到的元素的索引值
使用for循环遍历数组
1. 如果当前元素值等于要查找的元素valu
2. 把当前元素的索引值赋值给 index 结束循环break
循环结束返回index的值

main方法的实现步骤：

定义int数组array,并初始化
创建键盘录入Scanner类的对象
获取键盘录入的整数数字(要查找的数字),保存到int变量value中
调用getIndex方法,传递数组array和要查找的元素value,获取索引值保存到int变量index中
打印index的值

public class GetValue {
    public static void main(String[] args) {
        int[] array = {19, 28,37, 46, 50};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的元素(整数数字): ");
        int value = sc.nextInt();

        // 调用getIndex方法,传递数组array和要查找的元素value,获取索引值保存到int变量index中
        int index = getIndex2(value, array); 
        System.out.println("元素值"+value+"在数组中的索引值: "+index);
    }

    //定义方法,获取一个int数据,在int数组中第一次出现的索引值,如果没有出现返回-1
    public static int getIndex(int value, int[] array) {
        //定义int变量index,初始值-1,作用保存找到的元素的索引值
        int index = -1;

        //使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            // 如果当前元素值 等于 要查找的元素value
            if (array[i] == value) {
                // 把当前元素的索引值 赋值 给 index 结束循环break
                index = i;
                break;
            }

        }
        // 循环结束返回index的值
        return index;
    }

    //定义方法,获取一个int数据,在int数组中第一次出现的索引值,如果没有出现返回-1
    public static int getIndex2(int value, int[] array) {
       // 使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            // 如果当前元素值 等于 要查找的元素value
            if (array[i] == value) {
                // 直接返回当前元素的索引值
                return i;
            }
        }
        //执行到这里,说明数组中是没有value这个元素的,直接返回-1
        return -1;
    }
}

图解：

技术分享图片

两个int变量值的交换

需求：交换两个int变量的值

步骤：借助于第三个int变量

public class SwapVar {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a="+a);
        System.out.println("b="+b);
        //把变量a的值,(赋值)复制一份保存到int变量temp中
        int temp = a;
        //把变量b的值,(赋值)复制一份保存到int变量a中
        a = b;
        //把变量temp的值,(赋值)复制给变量b
        b = temp;

        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}

图解：

技术分享图片

数组元素的交换

需求：交换int数组两个元素的值

思考：如何定义一个方法,实现一个int数组中,两个位置的元素进行交换呢?

三要素：

方法名称: swap
参数列表: int[] array,int index1,int index2
返回值类型: void

public class SwapArray {
    public static void main(String[] args) {
        int[] arr = {10,20};
        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);

       //把数组arr中索引0的元素值,赋值给int变量temp
        int temp = arr[0];
        //把数组arr中索引1的元素值,赋值给数组arr中索引为0的元素
        arr[0] = arr[1];
        //把temp中的值,赋值给数组arr中索引为1的元素
        arr[1] = temp;

        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);
    }
    //定义一个方法,实现一个int数组中,两个位置的元素进行交换
    public static void swap(int[] arr, int index1, int index2) {
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
}

图解：

技术分享图片

数组反转分析

案例需求(不定义方法)：

已知一个数组 arr = {1, 2, 3, 4, 5};
用程序实现把数组中的元素值交换，交换后的数组 arr = {5, 4, 3, 2, 1};
并在控制台输出交换后的数组元素。

实现步骤：

定义int数组array,并初始化
调用方法(之前定义过,拿过来直接用),打印反转前的数组元素
使用for循环完成数组元素的反转(每次需要遍历获取到一对数据)
1. 初始化表达式: 找到第一对元素的索引值,定义2个int变量start和end,初始值分别为0和数组长度-1
2. 循环条件: 只要start 小于 end 说明又找到了一对需要交换的元素
3. 循环体: 实现start和end位置元素的交换
4. 步进表达式: 寻找下一对需要交换的元素 start++,end--
for循环结束,调用方法(之前定义过,拿过来直接用),打印反转后的数组元素

图解：

技术分享图片

代码实现（不定义方法）：

public class Demo01ReverseArray {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.print("数组反转前:" );
        printArray(array);

        //使用for循环完成数组元素的反转(每次需要遍历获取到一对数据)
        //初始化表达式: 找到第一对元素的索引值,定义2个int变量start和end,初始值分别为0和数组长度-1
        //循环条件: 只要start 小于 end 说明又找到了一对需要交换的元素
        //循环体: 实现start和end位置元素的交换
        //步进表达式: 寻找下一对需要交换的元素 start++,end--
        for(int start = 0,end = array.length-1;start<end;start++,end--) {
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;
        }
        //4.for循环结束,调用方法(之前定义过,拿过来直接用),打印反转后的数组元素
        System.out.print("数组反转后:" );
        printArray(array);
    }

    //打印int数组方法printArray的实现步骤
    public static void printArray(int[] array) {
        //1.打印"[",不换行
        System.out.print("[");

        //2.使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //2.1打印数组当前元素,不换行
            System.out.print(array[i]);

            //2.2如果步骤2.1中打印的元素不是最后一个元素,则需要打印", ",不换行
            if (i != array.length - 1) {
                System.out.print(", ");
            }
        }
        //3.打印"]",可以换行也可以不换行
        System.out.println("]");
    }
}

代码实现（定义方法）：

public class Demo02ReverseArray {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.print("数组反转前:" );
        printArray(array);

        //3.调用reverseArray方法,传递数组实现反转
        reverseArray(array);

        //4.for循环结束,调用方法(之前定义过,拿过来直接用),打印反转后的数组元素
        System.out.print("数组反转后:" );
        printArray(array);
    }
    //定义方法,实现一个int数组中元素的反转
    public static void reverseArray(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;
        }
    }
    //打印int数组方法printArray的实现步骤
    public static void printArray(int[] array) {
        //1.打印"[",不换行
        System.out.print("[");

        //2.使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //2.1打印数组当前元素,不换行
            System.out.print(array[i]);

            //2.2如果步骤2.1中打印的元素不是最后一个元素,则需要打印", ",不换行
            if (i != array.length - 1) {
                System.out.print(", ");
            }
        }
        //3.打印"]",可以换行也可以不换行
        System.out.println("]");
    }
}

图解：

评委打分

案例需求(不定义方法)：

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

实现步骤：

创建键盘录入Scanner类的对象
定义长度为6的int数组array,只能采用动态初始化方式
键盘录入六个0-100之间的数字存储到数组array中
使用for循环遍历查看数组内容

public class Demo01Score {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] array = new int[6];
        
        for (int i = 0; i < array.length; i++) {
            System.out.println("请输入第"+(i+1)+"个评委的评分:");
            array[i] = sc.nextInt();
        }
        //4.使用for循环遍历查看数组内容
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}

案例需求(不定义方法)：

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

实现步骤：

创建键盘录入Scanner类的对象
定义长度为6的int数组array,只能采用动态初始化方式
键盘录入六个0-100之间的数字存储到数组array中
使用for循环遍历查看数组内容
定义int变量sum,初始值0,用来统计总分
假设索引为0的元素是最大的,保存到int变量max中
假设索引为0的元素是最小的,保存到int变量min中
使用for循环遍历数组
1. 把当前元素值累加到求和变量sum中
2. 如果当前元素值大于 max 说明max中的值已经不是最大的了把当前元素值赋值给 max
3. 如果当前元素值小于 min 说明min中的值已经不是最小的了把当前元素值赋值给 min
for循环结束,根据需求计算平均值,保存到int变量avg中

public class Demo02Score {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] array = new int[6];

        //3.键盘录入六个0-100之间的数字存储到数组array中
        for (int i = 0; i < array.length; i++) {
            System.out.println("请输入第"+(i+1)+"个评委的评分:");
            array[i] = sc.nextInt();
        }
        //4.使用for循环遍历查看数组内容
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();

        //5.定义int变量sum,初始值0,用来统计总分
        int sum = 0;
        //6.假设索引为0的元素是最大的,保存到int变量max中
        int max = array[0];
        //7.假设索引为0的元素是最小的,保存到int变量min中
        int min = array[0];

        //8.使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //8.1把当前元素值累加到求和变量sum中
            sum += array[i];
            //8.2如果当前元素值 大于 max 说明max中的值已经不是最大的了  把当前元素值 赋值给 max
            if (array[i] > max) {
                max = array[i];
            }
            //8.3如果当前元素值 小于 min 说明min中的值已经不是最小的了  把当前元素值 赋值给 min
            if (array[i] < min) {
                min = array[i];
            }
        }
        //9.for循环结束,根据需求计算平均值,保存到int变量avg中
        System.out.println("和: "+sum);
        System.out.println("最大值: "+max);
        System.out.println("最小值: "+min);
        int avg = (sum - max - min)/(array.length-2);
        //10.打印avg的值
        System.out.println("平均值: "+avg);
    }
}

案例需求(定义方法)

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

定义方法：

定义方法getSum,获取一个int数组的元素之和
定义方法getMax,获取一个int数组的元素的最大值
定义方法getMin,获取一个int数组的元素的最小值

main方法的实现步骤：

创建键盘录入Scanner类的对象
定义长度为6的int数组array,只能采用动态初始化方式
键盘录入六个0-100之间的数字存储到数组array中
使用for循环遍历查看数组内容
调用getSum方法,获取数组元素之和,保存到int变量sum中
调用getMax方法,获取数组元素最大值,保存到int变量max中
调用getMin方法,获取数组元素最小值,保存到int变量min中
根据需求计算平均值,保存到int变量avg中
打印和,最大值,最小值和平均值

定义方法getSum,获取一个int数组的元素之和

三要素:

方法名称: getSum
参数列表: int[] array
返回值类型: int

public class Demo03Score {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] array = new int[6];

        //3.键盘录入六个0-100之间的数字存储到数组array中
        for (int i = 0; i < array.length; i++) {
            System.out.println("请输入第"+(i+1)+"个评委的评分:");
            array[i] = sc.nextInt();
        }

        //4.使用for循环遍历查看数组内容
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();

        //5.调用getSum方法,获取数组元素之和,保存到int变量sum中
        int sum = getSum(array);
        //6.调用getMax方法,获取数组元素最大值,保存到int变量max中
        int max = getMax(array);
        //7.调用getMin方法,获取数组元素最小值,保存到int变量min中
        int min = getMin(array);
        //8.根据需求计算平均值,保存到int变量avg中
        int avg = (sum - max - min)/(array.length-2);

        //9.打印和,最大值,最小值和平均值
        System.out.println("数组元素之和: "+sum);
        System.out.println("数组元素最大值: "+max);
        System.out.println("数组元素最小值: "+min);
        System.out.println("数组元素平均值: "+avg);
    }
    //3.定义方法getMin,获取一个int数组的元素的最小值
    public static int getMin(int[] array) {
        //1.假设索引为0的元素是最小的,保存到int变量min中
        int min = array[0];
        //2.使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //2.1如果当前元素值 小于 min 说明min中的值已经不是最小的了
            if (array[i] < min) {
                //把当前元素值,赋值给min
                min = array[i];
            }
        }
        //3.for循环结束返回min
        return min;
    }
    //2.定义方法getMax,获取一个int数组的元素的最大值
    public static int getMax(int[] array) {
        //1.假设索引为0的元素是最大的,保存到int变量max中
        int max = array[0];
        //2.使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //2.1如果当前元素值 大于 max 说明max中的值已经不是最大的了
            if (array[i] > max) {
                //把当前元素值,赋值给max
                max = array[i];
            }
        }
        return max;
    }
    //1.定义方法getSum,获取一个int数组的元素之和
    public static int getSum(int[] array) {
        //1.定义int变量sum,初始值0,用来累加求和
        int sum = 0;
        //2.使用for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            //2.1把当前元素累加到求和变量sum中
            sum += array[i];
        }
        return sum;
    }
}

java 练习题

原文：https://www.cnblogs.com/boyw/p/12922583.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)