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;
}
}
``
2762
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
