十.java入门【案例】

最新推荐文章于 2023-12-20 10:34:53 发布
最新推荐文章于 2023-12-20 10:34:53 发布
阅读量382 收藏
点赞数
分类专栏： java入门 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eemotion/article/details/110407772
版权
本文介绍了多个编程练习案例，包括根据星期数输出减肥活动、实现逢七必过规则、统计数组中满足特定条件的元素个数与和、数组元素查找、反转以及评委打分的平均得分计算。这些练习涵盖了基本的条件判断、数组操作和简单的算法应用。
摘要由CSDN通过智能技术生成

day10 【练习】

减肥计划案例
逢七必过案例
统计成绩
数组求和
数组中的元素查找案例
数组中的元素反转
评委打分案例
    
快捷键:
    自动分配变量
        new Xxx(...).var  或者 new Xxx(...) alt + 回车
        方法调用(...).var 或者 方法调用(...) alt + 回车

    生成输出语句
        表达式.sout
        方法调用(...).sout

第一章 基础练习

1.1 减肥计划if版本
需求
	输入星期数[1,7]，显示今天的减肥活动 
    	周一：跑步 
    	周二：游泳 
    	周三：慢走 
    	周四：动感单车 
    	周五：拳击 
    	周六：爬山 
    	周日：好好吃一顿
实现步骤:
	1.创建键盘录入Scanner类的对象
    2.获取键盘录入的1-7的整数数字(代表星期数),保存到int变量week中
    3.因为week中的数字有7+1种情况,所以使用if语句的第三种格式对week中的数据进行判断,并输出不同的结果
public class Demo01IfJF {
    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) {
            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("好好吃一顿");
        } else {//隐藏条件: week<1 || week>7
            System.out.println("您输入的数字有误...............");
        }

        System.out.println("main....end...");
    }
}
public class Demo02IfJF {
    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) {//执行到这个位置: week>=1 && week<=7 而且都是int数字,那么week取值: 1,2,3,4,5,6,7
            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)*/ {//隐藏条件: week == 7
            System.out.println("好好吃一顿");
        }

        System.out.println("main....end...");
    }
}
1.2 减肥计划switch版本
减肥计划switch版本
需求
	输入星期数[1,7]，显示今天的减肥活动 
    	周一：跑步 
    	周二：游泳 
    	周三：慢走 
    	周四：动感单车 
    	周五：拳击 
    	周六：爬山 
    	周日：好好吃一顿
实现步骤:
 	1.创建键盘录入Scanner类的对象
    2.获取键盘录入的1-7的整数数字(代表星期数),保存到int变量week中
    3.因为week中的数字有7+1种情况,所以使用switch语句对week中的数据进行判断,并输出不同的结果
public class Demo03SwitchJF {
    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.3 逢七跳过
需求:
	在控制台打印出1-100之间的满足 逢七必过 规则(数字包含7或者是7的倍数) 的数据,以及总个数。
    逢七必过 规则(数字num包含7或者是7的倍数): (个位==7 或者 十位==7) 或者 (num%7==0)
        
实现步骤:
	1.定义int变量count,初始值0,用来统计满足逢七过规则的数据
	2.使用for循环获取1-100之间的数字,循环变量int类型num
    2.1计算当前num中数字的个位和十位,分别保存到int变量ge和shi中
    2.2如果 个位 等于 7 或者 十位 等于 7 或者 num中的数字是7的倍数
        a.打印num中的数字
        b.计数器count的值增加1
    3.循环结束打印count的值
public class Demo05FQG {
    public static void main(String[] args) {
        //1.定义int变量count,初始值0,用来统计满足逢七过规则的数据
        int count = 0;

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

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

                //b.计数器count的值增加1
                count++;
            }

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

第二章 数组练习

2.1 数组元素求和
数组元素求和
案例需求
	有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。打印该数组中满足要求的元素和以及总个数 
    要求是：求和的元素个位和十位都不能是7，并且只能是偶数
    		(ge!=7 && shi!=7) && (array[i]%2==0)
    
实现步骤:
	1.定义int变量count,初始值0,用来统计满足条件的数据的数量
    2.定义int数组array,并按照题目要求进行初始化
    3.使用for循环遍历数组
        3.1 计算当前元素的个位和十位,分别保存到int变量ge和shi中
        3.2 判断如果 个位 是 7 并且 十位 是 7  并且 当前元素是偶数
        	a.打印当前元素值
        	b.计数器count的值增加1
    4.循环结束后,打印count的值
public class Demo01Array {
    public static void main(String[] args) {
        //1.定义int变量count,初始值0,用来统计满足条件的数据的数量
        int count = 0;

        //2.定义int数组array,并按照题目要求进行初始化
        int[] array = {68,27,95,88,171,996,51,210};

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

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

                //b.计数器count的值增加1
                count++;
            }

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

数组元素求和
案例需求
	有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和以及总个数 
    要求是：求和的元素个位和十位都不能是7，并且只能是偶数
    		(ge!=7 && shi!=7) && (array[i]%2==0)
    
实现步骤:
	0.定义int变量sum,初始值0,用来累加求和
	1.定义int变量count,初始值0,用来统计满足条件的数据的数量
    2.定义int数组array,并按照题目要求进行初始化
    3.使用for循环遍历数组
        3.1 计算当前元素的个位和十位,分别保存到int变量ge和shi中
        3.2 判断如果 个位 是 7 并且 十位 是 7  并且 当前元素是偶数
        	a.打印当前元素值
        	b.计数器count的值增加1
        	c.把当前元素累加到求和变量sum中
    4.循环结束后,打印count的值
    5.打印sum的值
public class Demo02Array {
    public static void main(String[] args) {
        //0.定义int变量sum,初始值0,用来累加求和
        int sum = 0;

        //1.定义int变量count,初始值0,用来统计满足条件的数据的数量
        int count = 0;

        //2.定义int数组array,并按照题目要求进行初始化
        int[] array = {68,27,95,88,171,996,51,210};

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

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

                //b.计数器count的值增加1
                count++;

                //c.把当前元素累加到求和变量sum中
                sum = sum + array[i];
            }

        }
        //4.循环结束后,打印count的值
        System.out.println("满足条件的元素数量: "+count);
        //5.打印sum的值
        System.out.println("满足条件的元素和: "+sum);
    }
}
2.2 数组统计学生成绩
数组统计学生成绩
案例需求
    1.键盘录入班级人数
    2.根据录入的班级人数创建数组
    3.利用随机数产生0-100的成绩(包含0和100)
    4.要求:
		(1)打印该班级的不及格人数 
        (2)打印该班级所有学生的平均分
    	(3)演示格式如下: 
			请输入班级人数: 
			键盘录入:100 
            控制台输出: 
			不及格人数:19 
            班级平均分:87
实现步骤:
 	1.创建键盘录入Scanner类的对象
	2.创建产生随机数的Random类的对象
    3.获取键盘录入的整数数字(代表班级人数), 保存到int变量size中
    4.创建长度为size的int数组array,只能采用动态初始化方式创建数组
    5.按照要求产生size个随机数字,存储到数组array中
    6.打印数组array中的元素(目的: 看数组中有没有存储对应的随机数字)
    7.定义int变量count,初始值0,用来统计不及格人数
    8.定义int变量sum,初始值0,用来统计所有学生的成绩之和
    9.使用for循环遍历数组
    9.1把当前元素累加到求和变量sum中
    9.2如果当前元素值 小于 60 计数器count的值增加1
    10.for循环结束后,根据总分sum计算出平均分,保存到int变量avg中
    11.打印count和avg的值
        
public class Demo03Score {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

        //2.创建产生随机数的Random类的对象
        Random r = new Random();

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

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

        //5.按照要求产生size个随机数字,存储到数组array中
        //[0,100] ==> r.nextInt(101)
        /*array[0] = r.nextInt(101);
        array[1] = r.nextInt(101);
        //...
        array[size-1] = r.nextInt(101);*/
        for (int i = 0; i < array.length; i++) {
            //生成一个[0,100]之间的随机数字,保存到int变量num中
            //int num = r.nextInt(101);
            //array[i] = num;

            array[i] = r.nextInt(101);
        }

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

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

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

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

            //9.2如果当前元素值 小于 60 计数器count的值增加1
            if (array[i] < 60) {
                count++;
            }
        }

        //10.for循环结束后,根据总分sum计算出平均分,保存到int变量avg中
        int avg = sum / (array.length);

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

第三章 方法练习

3.1 查找元素在数组中第一次出现的索引位置
案例需求(不定义方法)
	已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。
	并在控制台输出找到的索引值。如果没有查找到，则输出-1
    
实现步骤:
	1.定义int数组array,并初始化
	2.创建键盘录入Scanner类的对象
	3.获取键盘录入的整数数字(要查找的数字),保存到int变量value中
	4.定义int变量index,初始值-1,作用保存找到的元素的索引值
	5.使用for循环遍历数组
	5.1如果当前元素值 等于 要查找的元素value
	5.2把当前元素的索引值 赋值 给 index 结束循环break
	6.循环结束直接打印变量index的值
public class Demo01GetValue {
    public static void main(String[] args) {
        //1.定义int数组array,并初始化
        int[] array = {19, 28,37, 46, 50};

        //2.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

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

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

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

        }
        //6.循环结束直接打印变量index的值
        System.out.println("元素值"+value+"在数组中的索引值: "+index);
    }
}
    

/*
    案例需求(定义方法)
        已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。
        并在控制台输出找到的索引值。如果没有查找到，则输出-1

    实现步骤:


    定义方法,获取一个int数据,在int数组中第一次出现的索引值,如果没有出现返回-1
    三要素:
        1.方法名称:     getIndex
        2.参数列表:     int[] array,int value
        3.返回值类型:    int

    getIndex方法的实现步骤:
        1.定义int变量index,初始值-1,作用保存找到的元素的索引值
        2.使用for循环遍历数组
        3.1如果当前元素值 等于 要查找的元素value
        3.2把当前元素的索引值 赋值 给 index 结束循环break
        4.循环结束返回index的值

    main方法的实现步骤:
        1.定义int数组array,并初始化
        2.创建键盘录入Scanner类的对象
        3.获取键盘录入的整数数字(要查找的数字),保存到int变量value中
        4.调用getIndex方法,传递数组array和要查找的元素value,获取索引值保存到int变量index中
        5.打印index的值
 */
public class Demo02GetValue {
    public static void main(String[] args) {
        //1.定义int数组array,并初始化
        int[] array = {19, 28,37, 46, 50};

        //2.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

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

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

        //5.打印index的值
        System.out.println("元素值"+value+"在数组中的索引值: "+index);
    }

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

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

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

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

    思想:
        借助于第三个int变量
 */
public class Demo01SwapVar {
    public static void main(String[] args) {
        //1.定义两个int变量并初始化
        int a = 10;
        int b = 20;
        System.out.println("a="+a);
        System.out.println("b="+b);

        //2.定义int变量team,初始化值是a变量中的值
        int temp = a;//把变量a的值,(赋值)复制一份保存到int变量temp中

        a = b;//把变量b的值,(赋值)复制一份保存到int变量a中

        b = temp;//把变量temp的值,(赋值)复制给变量b


        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}
3.3 数组元素的交换
/*
    需求:
        交换int数组两个元素的值

    思想:
        借助于第三个int变量

    思考:
        如何定义一个方法,实现一个int数组中,两个位置的元素进行交换呢?
        三要素:
            1.方法名称:     swap
            2.参数列表:     int[] array,int index1,int index2
            3.返回值类型:    void
 */
public class Demo02SwapArray {
    public static void main(String[] args) {
        //1.定义int数组array,并初始化
        int[] arr = {10,20};

        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);

        //2.定义int变量temp,初始化值是索引0对应的元素值
        int temp = arr[0];//把数组arr中索引0的元素值,赋值给int变量temp

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

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


        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;
    }
}
3.4 数组反转分析
案例需求(不定义方法)
	已知一个数组 arr = {1, 2, 3, 4, 5}; 
	用程序实现把数组中的元素值交换， 交换后的数组 arr = {5, 4, 3, 2, 1};
	并在控制台输出交换后的数组元素。
        
实现步骤:        
	1.定义int数组array,并初始化
    2.调用方法(之前定义过,拿过来直接用),打印反转前的数组元素
    3.使用for循环完成数组元素的反转(每次需要遍历获取到一对数据)
        3.1初始化表达式: 找到第一对元素的索引值,定义2个int变量start和end,初始值分别为0和数组长度-1
        3.2循环条件: 只要start 小于 end 说明又找到了一对需要交换的元素
        3.3循环体: 实现start和end位置元素的交换
        3.4步进表达式: 寻找下一对需要交换的元素 start++,end--
    4.for循环结束,调用方法(之前定义过,拿过来直接用),打印反转后的数组元素
3.5 数组反转代码实现
/*
    案例需求(不定义方法)
        已知一个数组 arr = {1, 2, 3, 4, 5};
        用程序实现把数组中的元素值交换， 交换后的数组 arr = {5, 4, 3, 2, 1};
        并在控制台输出交换后的数组元素。

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

        //2.调用方法(之前定义过,拿过来直接用),打印反转前的数组元素
        System.out.print("数组反转前:" );
        printArray(array);

        //3.使用for循环完成数组元素的反转(每次需要遍历获取到一对数据)
        //3.1初始化表达式: 找到第一对元素的索引值,定义2个int变量start和end,初始值分别为0和数组长度-1
        //3.2循环条件: 只要start 小于 end 说明又找到了一对需要交换的元素
        //3.3循环体: 实现start和end位置元素的交换
        //3.4步进表达式: 寻找下一对需要交换的元素 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("]");
    }
}


/*
    案例需求(定义方法)
        已知一个数组 arr = {1, 2, 3, 4, 5};
        用程序实现把数组中的元素值交换， 交换后的数组 arr = {5, 4, 3, 2, 1};
        并在控制台输出交换后的数组元素。

    main方法实现步骤:
        1.定义int数组array,并初始化
        2.调用方法(之前定义过,拿过来直接用),打印反转前的数组元素
        3.调用reverseArray方法,传递数组实现反转
        4.for循环结束,调用方法(之前定义过,拿过来直接用),打印反转后的数组元素

    定义方法,实现一个int数组中元素的反转
    三要素:
        1.方法名称:     reverseArray
        2.参数列表:     int[] array
        3.返回值类型:   void
 */
public class Demo02ReverseArray {
    public static void main(String[] args) {
        //1.定义int数组array,并初始化
        int[] array = {1, 2, 3, 4, 5};

        //2.调用方法(之前定义过,拿过来直接用),打印反转前的数组元素
        System.out.print("数组反转前:" );
        printArray(array);

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

        //4.for循环结束,调用方法(之前定义过,拿过来直接用),打印反转后的数组元素
        System.out.print("数组反转后:" );
        printArray(array);
    }

    //定义方法,实现一个int数组中元素的反转
    public static void reverseArray(int[] array) {
        //3.使用for循环完成数组元素的反转(每次需要遍历获取到一对数据)
        //3.1初始化表达式: 找到第一对元素的索引值,定义2个int变量start和end,初始值分别为0和数组长度-1
        //3.2循环条件: 只要start 小于 end 说明又找到了一对需要交换的元素
        //3.3循环体: 实现start和end位置元素的交换
        //3.4步进表达式: 寻找下一对需要交换的元素 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;
        }
    }


    //打印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("]");
    }
}
3.6 评委打分
/*
    评委打分(不定义方法)
    案例需求
        在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
        选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

    实现步骤:
        1.创建键盘录入Scanner类的对象
        2.定义长度为6的int数组array,只能采用动态初始化方式
        3.键盘录入六个0-100之间的数字存储到数组array中
        4.使用for循环遍历查看数组内容
 */
public class Demo01Score {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

        //2.定义长度为6的int数组array,只能采用动态初始化方式
        int[] array = new int[6];

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

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

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

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

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

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

        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个评委平均值 (不考虑小数部分)。

    实现步骤:
        1.创建键盘录入Scanner类的对象
        2.定义长度为6的int数组array,只能采用动态初始化方式
        3.键盘录入六个0-100之间的数字存储到数组array中
        4.使用for循环遍历查看数组内容
        5.定义int变量sum,初始值0,用来统计总分
        6.假设索引为0的元素是最大的,保存到int变量max中
        7.假设索引为0的元素是最小的,保存到int变量min中
        8.使用for循环遍历数组
        8.1把当前元素值累加到求和变量sum中
        8.2如果当前元素值 大于 max 说明max中的值已经不是最大的了  把当前元素值 赋值给 max
        8.3如果当前元素值 小于 min 说明min中的值已经不是最小的了  把当前元素值 赋值给 min
        9.for循环结束,根据需求计算平均值,保存到int变量avg中
        10.打印avg的值
 */
public class Demo02Score {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

        //2.定义长度为6的int数组array,只能采用动态初始化方式
        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个评委平均值 (不考虑小数部分)。

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

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

    1.定义方法getSum,获取一个int数组的元素之和
    三要素:
        1.方法名称:   getSum
        2.参数列表:   int[] array
        3.返回值类型: int
 */
public class Demo03Score {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);

        //2.定义长度为6的int数组array,只能采用动态初始化方式
        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];
            }
        }
        //3.for循环结束返回max
        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];
        }
        //3.返回sum
        return sum;
    }
}

``

JuGeGer
关注
专栏目录
python3中如何表示无穷大
sonia_liss的博客
05-28 3969
正无穷 float("inf") 负无穷 float('-Inf') 验证 float('-Inf') ==-float('Inf') true _isnan(double x); //判断是否为NAN _finite(double x); //判读是否为无穷大
JAVA新手入门60个案例.zip
01-29
"JAVA新手入门60个案例.zip" 提供了60个精心设计的Java实战项目，旨在帮助新手逐步熟悉并精通Java编程。 这些案例覆盖了Java的基础到进阶知识点，包括但不限于以下方面： 1. **基本语法**：案例可能涵盖变量声明、...
python中数字应该用什么表示_python的特殊数字类型（无穷大、无穷小等）
weixin_39646018的博客
12-02 1409
float('inf') 表示正无穷-float('inf') 或 float('-inf') 表示负无穷其中，inf 均可以写成 Inf起步python中整型不用担心溢出，因为python理论上可以表示无限大的整数，直到把内存挤爆。而无穷大在编程中常常需要的。比如，从一组数字中筛选出最小的数字。一般使用一个临时变量用于存储最后结果，变量去逐个比较和不断地更新。而这临时变量一般要初始无穷大或者去第...
python中自然数怎么表示_Python 表示无穷大的数
weixin_39831242的博客
11-29 2498
我之前只知道设置初始值0.今天偶然在Python算法书上看到这个片段,从100个随机数里面找2个最靠近的自然数(不相等):from random importrandrangeseq= [randrange(10**10) for i in range(100)]dd= float("inf")for x inseq:for y inseq:if x == y: continued= abs(x-...
python计算无穷大
weixin_46121540的博客
12-20 1560
例如，任何数乘以无穷大都是无穷大，任何数除以无穷大都是0，无穷大除以无穷大是NaN，等等。在这个例子中，步长被设置为无穷大，所以每次迭代都会沿着梯度的相反方向前进，无论梯度有多小。在Python中是非常有用的工具，它们可以用于各种不同的应用场景。在这个例子中，棋盘的左上角被设置为无穷大，表示一个非常大的边界值。在这个例子中，第二个数据点被设置为无穷大，表示一个非常高的柱子。将被设置为无穷大，表示没有可用的平均值。的值被设置为无穷大，表示它无法被吃掉。当然，除了基本的数学运算，当然，除了上述的应用，
python 中无穷大的表示方法
ZHE
04-20 9710
float(‘inf’) 表示正无穷 -float(‘inf’) 或 float(’-inf’) 表示负无穷 其中，inf 均可以写成 Inf
java入门案例4借鉴.pdf
12-25
总结来说，这个Java入门案例的核心知识点包括： 1. 嵌套循环的使用：一个循环控制行数，另一个循环控制每行的乘法表达式数量。 2. `for`循环的结构：初始化、条件判断和递增/递减部分。 3. `System.out.print`和`...
Java开发案例-springboot-11-定时任务入门-源代码+文档.rar
最新发布
05-31
Java开发案例-springboot-11-定时任务入门-源代码+文档.rar Java开发案例-springboot-11-定时任务入门-源代码+文档.rar Java开发案例-springboot-11-定时任务入门-源代码+文档.rarJava开发案例-springboot-11-定时...
java入门案例4[归纳].pdf
10-11
Java 入门案例4主要讲解了如何使用Java编程语言实现九九乘法表。这个案例是初学者学习控制流程和输出格式化的重要实践。 在Java中，九九乘法表的实现主要涉及到嵌套循环的概念。一个外层循环用于控制行数，一个内层...
Java基础案例教程（第2版）-教学设计.zip
07-06
"程序，这是编程入门的经典案例。 接着，教程会深入讲解Java语法基础，包括数据类型（基本类型与引用类型）、变量、常量、运算符、流程控制语句（如if-else、switch、for、while等）。这些知识点是构建任何程序的...
Python 中无穷的表示
weixin_44178960的博客
05-26 3564
我们在python编程过程中可能需要设定一个无穷大的值来辅助我们的逻辑语句，下面展示python中无穷大的表示，和无穷的判断方法。上代码！！！ # 无穷的判断需要导入math模块 import math # 正无穷 zheng_wq = float('inf') # 负无穷 fu_wq = -float('inf') #float('-inf') # 判断是否无穷 math.isinf(zhengwq) #最终结果是True 希望我的笔记能够帮到您，谢谢您的观看！！！ ...
python中无穷大与无穷小表示
热门推荐
hellojoy的博客
07-17 7万+
float('inf') 表示正无穷 -float('inf') 或 float('-inf') 表示负无穷 其中，inf 均可以写成 Inf   起步 python中整型不用担心溢出，因为python理论上可以表示无限大的整数，直到把内存挤爆。而无穷大在编程中常常需要的。比如，从一组数字中筛选出最小的数字。一般使用一个临时变量用于存储最后结果，变量去逐个比较和不断地更新。而这临时变量一...
Python中无穷大与无穷小表示
jiangjiane
06-22 1万+
float('inf') 表示正无穷-float('inf') 或 float('-inf') 表示负无穷其中，inf 均可以写成 Inf
python的特殊数字类型（无穷大、无穷小等）
weixin_30267697的博客
06-12 215
float('inf') 表示正无穷 -float('inf') 或 float('-inf') 表示负无穷 其中，inf 均可以写成 Inf 起步python中整型不用担心溢出，因为python理论上可以表示无限大的整数，直到把内存挤爆。而无穷大在编程中常常需要的。比如，从一组数字中筛选出最小的数字。一般使用一个临时变量用于存储最后结果，变量去逐个比较和不断地更新。而这临时变量一般要...
Python的特殊数字类型（无穷大、无穷小等）
厚积而薄发
03-16 3347
文章目录1.无穷大和无穷小2.nan 1.无穷大和无穷小 >>> float('inf') # 正无穷 inf >>> float('-inf') # 负无穷 -inf inf 均可以写成 Inf python中整型不用担心溢出，因为python理论上可以表示无限大的整数，直到把内存挤爆。而无穷大在编程中常常需要的。比如，从一组数字中筛选出最小的数字。一般使用一个临时变量用于存储最后结果，变量去逐个比较和不断地更新。而这临时变量一般要初始无穷大或者去第一个元素的值。 2
Python 表示无穷大的数
weixin_33881753的博客
11-12 584
我之前只知道设置初始值0.今天偶然在Python算法书上看到这个片段,从100个随机数里面找2个最靠近的自然数(不相等): from random import randrange seq = [randrange(10**10) for i in range(100)] dd = float("inf") for x in seq: for y in seq: ...
Python 无穷大无穷小 inf -inf
linian71的专栏
01-16 1562
无穷大：float('inf') 无穷小：float('-inf') In [1]: a = float('inf') In [2]: 1 Out[2]: True In [3]: 10000000 > a Out[3]: False In [4]: b = float('-inf') In
python 中 infinity(inf-无穷)、Nan(not a number)和None
qq_42527487的博客
05-21 8794
1、inf python中的正无穷或负无穷，使用float("inf")或float("-inf")来表示。 这里有点特殊，写成：float("inf")，float("INF")或者float('Inf')都是可以的。 当涉及 > 和 < 比较时，所有数都比无穷小float("-inf")大，所有数都比无穷大float("inf")小。 相等比较时，float("+inf")与fl...
【Python】python中无穷大与无穷小表示【转载】
weixin_43868754的博客
06-04 901
原文链接：https://blog.csdn.net/hellojoy/article/details/81077019 float(‘inf’) 表示正无穷 -float(‘inf’) 或 float(’-inf’) 表示负无穷 其中，inf 均可以写成 Inf 起步 python中整型不用担心溢出，因为python理论上可以表示无限大的整数，直到把内存挤爆。而无穷大在编程中常常需要的。比如，从一组数字中筛选出最小的数字。一般使用一个临时变量用于存储最后结果，变量去逐个比较和不断地更新。而这临时变量.
Java基础教程：从SetApple.java入门到实战应用
《SetApplejava-JAVA自学教程》是一本全面且实用的Java学习资料，适合想要入门或者提升Java编程能力的读者。通过跟随教程，学习者将逐渐熟悉Java编程的环境搭建、语法结构、面向对象编程思想，以及实际项目中的关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值