Java练习题-06

1.（一维数组的应用）从控制台输入6名员工的工资装入数组遍历输出。计算出6名员工的总工资和平均工资，工资使用double类型。思路提示：循环外定义变量存储工资的和，然后在循环体中使用“+=”累加数组中每个元素。

@Test
	//计算员工平均工资
	public void test2() {
		double salary = 0;
		double salaryArr[] = new double[6];  //动态数组
//		double salaryArr[]  = {0,0,0,0,0,0};   //静态定义数组
		double totle = 0; //总工资
		double avg = 0; //平均工资
		for(int i= 0;i<salaryArr.length;i++) {
			System.out.print("请输入员工的工资：");
			salary = new Scanner(System.in).nextDouble();
			salaryArr[i]=salary;
			totle+=salaryArr[i];
		}
		avg = totle/salaryArr.length;
		System.out.println("六个员工的总工资为："+totle);
		System.out.println("六个员工的平均工资为："+avg);	
	}

请输入员工的工资：3500
请输入员工的工资：8000
请输入员工的工资：5000
请输入员工的工资：5600
请输入员工的工资：6600
请输入员工的工资：7000
六个员工的总工资为：35700.0
六个员工的平均工资为：5950.0

2. 输出数组中的最大值、 最小值、求和。

@Test
	//输出数组中的最大值  最小值 求和 
	public void test3() {
		int arr[] = {56,34,78,2,0,18};
		int max = arr[0];
		int min = arr[0];
		int sum = 0;
		System.out.print("数组的元素有：");
		for(int i=0;i<arr.length-1;i++) {
			System.out.print(arr[i]+"   ");
			sum+=arr[i];
			if(arr[i]>max) {
				max = arr[i];
				}else if(arr[i]<min) {
					min = arr[i];
				}
			}
		System.out.println("");
		System.out.println("最大值为："+max);
		System.out.println("最小值为："+min);
		System.out.println("数组元素和为："+sum);
	}
	

数组的元素有：56   34   78   2   0   
最大值为：78
最小值为：0
数组元素和为：170

3. 输出数组中的最大值

@Test
	//数组中的最大值
	public void test4() {
		int arr[] = {56,34,78,2,0,18};
		Arrays.sort(arr);   //排序方法。顺序（从小到大）
		for(int i = 0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
		System.out.println("最大值："+arr[arr.length-1]);
	}
	

0
2
18
34
56
78
最大值：78

4. 将数组排序从大到小输出 ，将数组转换为字符串。

@Test
	//从大到小 从小到大输出  将数组转换为字符串
	public void test5() {
		int arr[] = {56,34,78,2,0,18};
		Arrays.sort(arr);  //排序方法。顺序（从小到大）
		for(int i = 0;i<arr.length;i++) {
			System.out.println(arr[arr.length-i-1]);  //从大到小输出
		}
		String s=Arrays.toString(arr); //将数组转换为字符串
		System.out.println(s);
	}
	

78
56
34
18
2
0
[0, 2, 18, 34, 56, 78]

5. 一维数组的应用）从控制台输入小组成员的姓名，然后遍历输出小组成员的姓名。
思路提示：首先确定小组成员，动态初始化数组，根据输入的姓名给数组赋值。遍历字符串数组。

public void work1() {
		String[] group = new String[6];
		for(int i=0;i<group.length;i++) {
			System.out.print("请输入小组成员的姓名：");
			String name = new Scanner(System.in).next();
			group[i]=name;
		}
		for(int i=0;i<group.length;i++) {
			System.out.print(group[i]+",");
		}
	}

请输入小组成员的姓名：张三
请输入小组成员的姓名：李四
请输入小组成员的姓名：王五
请输入小组成员的姓名：赵六
请输入小组成员的姓名：小七
请输入小组成员的姓名：王大
张三,李四,王五,赵六,小七,王大,

6. （一维数组的应用）需求：查找元素：查找班级指定同学姓名。思路分析：定义一个空数组，将班级中十位同学的名字存到数组中。从键盘任意输入一个名字，判断该同学是否是这个班级的同学。

	@Test
	//查找元素：查找班级指定同学姓名。 方法1
	public void work2() {
		String[] class1= new String[10];
		Scanner sc = new Scanner(System.in);
		for(int i=0;i<class1.length;i++) {
			System.out.print("请输入该班级学生的姓名：");
			String name = sc.next();
			class1[i]=name;
		}
		System.out.print("请输入你要查找的学生姓名：");
		String name1 = sc.next();
		for(int i = 0;i<class1.length;i++) {
		if(name1.equals(class1[i])) {
			System.out.println("该学生是本班级的学生");
			break;
		}else if(i==class1.length-1) {
			System.out.println("该学生不是本班级的学生");
		}
		}
		}
	

    @Test
	//查找元素：查找班级指定同学姓名。 方法2
	public void work3() {
		String[] class1= new String[10];
		Scanner sc = new Scanner(System.in);
		for(int i=0;i<class1.length;i++) {
			System.out.print("请输入该班级学生的姓名：");
			String name = sc.next();
			class1[i]=name;
		}
		System.out.print("请输入你要查找的学生姓名：");
		String name1 = sc.next();
		boolean isok=false;
		for(int i = 0;i<class1.length;i++) {
		if(name1.equals(class1[i])) {
			isok=true;
			break;
		}
		}
		if(isok) {
			System.out.println("该学生是本班的学生");
		}else {
			System.out.println("不是本班学生");
		}
		}

请输入该班级学生的姓名：张三
请输入该班级学生的姓名：李四
请输入该班级学生的姓名：王五
请输入该班级学生的姓名：赵六
请输入该班级学生的姓名：赵丽颖
请输入该班级学生的姓名：周杰伦
请输入该班级学生的姓名：陈学冬
请输入该班级学生的姓名：张学友
请输入该班级学生的姓名：迪丽热巴
请输入该班级学生的姓名：王杰
请输入你要查找的学生姓名：张学友
该学生是本班级的学生

7. （一维数组的应用）案例介绍：定义一个有7个元素的数组，从键盘任意输入一个数，判断是否在数组中存在， 如果存在，提示“猜对了”，否则输出“Sorry！！”。

需求说明：
数组元素为图中规定数据
键盘输入数据
用两种方式实现

public void work4() {
		int[] arr = {1,62,73,12,5,99,77};
		System.out.print("请输入一个数：");
		int a = new Scanner(System.in).nextInt();
		for(int i = 0; i<arr.length;i++) {
			if(a==arr[i]) {
				System.out.println("你猜对了！");
				break;
			}else if(i==arr.length-1) {
				System.out.println("sorry！！");
			}
		}
	}

请输入一个数：5
你猜对了！

8. （一维数组的应用）有这样一个数列：12，23，13，44，123，456，求这个数列的最小值

public void work5() {
		int[] arr= {12,23,13,44,123,456};
		int min = arr[0];
		for(int i = 0; i<arr.length;i++) {
			if(arr[i]<min) {
				min=arr[i];
			}
		}
		System.out.println("最小值为："+min);
	}
	

最小值为：12

9. （进阶-一维数组的应用）案例需求：完成学生管理系统

案例思路：
通过键盘录入学生成绩存入成绩数组。
通过调用方法实现最高分，最低分，总分，
平均分及成材率的功能。

public void work6() {
		int[] grades= new int[5];
		int sum = 0;
		int avg = 0;
		double n = 0;  //大于90分以上的人数
		for(int i = 0;i<grades.length;i++) {
			System.out.print("请输入第"+(i+1)+"学生的成绩：");
			int grade = new Scanner(System.in).nextInt();
			grades[i]=grade;
			sum+=grades[i];
			if(grades[i]>90) {
				n++;
			}
		}
		Arrays.sort(grades);
		avg=sum/grades.length;
		System.out.println("各个同学的得分是："+Arrays.toString(grades));
		System.out.println("最低分："+grades[0]);
		System.out.println("最高分："+grades[grades.length-1]);
		System.out.println("平均分："+avg);
		System.out.println("学生成绩总和："+sum);
		System.out.println("本班学生成材率为"+n/grades.length*100+"%");
		
	}
	

请输入第1学生的成绩：98
请输入第2学生的成绩：99
请输入第3学生的成绩：68
请输入第4学生的成绩：78
请输入第5学生的成绩：65
各个同学的得分是：[65, 68, 78, 98, 99]
最低分：65
最高分：99
平均分：81
学生成绩总和：408
本班学生成材率为40.0%

 

10. （进阶--选择结构、循环、一维数组的应用）自定义一个数组里面有7个元素的数组，从键盘任意输入一个数，判断是否在数组中存在， 如果存在，提示“猜对了”，否则输出“Sorry！！”。

@Test
	public void work8() {
		int[] arr= {1,89,78,74,78,12,13};
		boolean isok = false;
		System.out.println("请输入一个数字：");
		int n = new Scanner(System.in).nextInt();
		for(int i = 0;i<arr.length;i++) {
			if(n==arr[i]) {
				isok=true;
				break;
			}
		}
		if(isok) {
			System.out.println("猜对了！");
		}else {
			System.out.println("sorry!!");
		}
		
	}

请输入一个数字：
5
sorry!!

11. （一维数组的应用）依次从键盘录入数组元素，然后把数组元素逆序输出 (就是把元素对调)

public void work9() {
		int[] arr = new int[5];
		for(int i = 0;i<arr.length;i++) {
		System.out.print("请输入第"+(i+1)+"个数组元素：");
		int num = new Scanner(System.in).nextInt();
		arr[i]=num;
		
		}
		System.out.println("对调前：");
		for(int i =0;i<arr.length;i++) {
			System.out.print(arr[i]+",");
		}
		System.out.println("");
		System.out.println("对调后：");
		for(int i =0;i<arr.length;i++) {
			System.out.print(arr[arr.length-i-1]+",");
		}
		
	}

请输入第1个数组元素：4
请输入第2个数组元素：5
请输入第3个数组元素：8
请输入第4个数组元素：12
请输入第5个数组元素：56
对调前：
4,5,8,12,56,
对调后：
56,12,8,5,4,

12. （二维数组的应用）需求：从键盘输入2名学生的数学，语文，英语成绩放入二维数组，然后遍历输出。

思路提示：
动态初始化二维数组（两行三列）
使用for循环从键盘输入数据，给二维数组元素赋值
For循环中依次输入数学，语文，英语成绩。输入后通过下标赋值给数组元素
使用两层for循环遍历数组

    @Test
	public void work10() {
		int[][] grade = new int[2][3]; //行 列 
		for(int i = 0; i<grade.length;i++) {
			for(int j = 0;j<grade[i].length;j++) {
				System.out.print("请输入学生的成绩：");
				int grade1 = new Scanner(System.in).nextInt();
				grade[i][j]=grade1;	
			}
		}
		System.out.println("第一名学生的成绩为：");
		for(int j = 0;j<grade[0].length;j++) {
			System.out.print(grade[0][j]+"  ");
			}
		System.out.println("");
		System.out.println("第二名学生的成绩为：");
		for(int j = 0;j<grade[1].length;j++) {
			System.out.print(grade[1][j]+"  ");
			}
			
		}
	

请输入学生的成绩：98
请输入学生的成绩：75
请输入学生的成绩：65
请输入学生的成绩：88
请输入学生的成绩：78
请输入学生的成绩：96
第一名学生的成绩为：
98  75  65  
第二名学生的成绩为：
88  78  96  

13.（二维数组的应用） 选择省份输出该省份下的市区。

@Test
	public void work11(){
		String[][] cities = new String[3][4];
		cities[0]= new String[]{"长春市","吉林市","四平市","通化市"};
		cities[1]= new String[]{"沈阳市","大连市","丹东市","营口市"};
		cities[2]= new String[]{"哈尔滨市","齐齐哈尔市","佳木斯市","漠河市"};
		System.out.println("请选择省份：0=吉林省，1=辽宁省，2=黑龙江省，3=全部");
		int choose = new Scanner(System.in).nextInt();
		switch(choose) {
		case 0:
			for(int i = 0; i<cities[0].length;i++) {
					System.out.print(cities[0][i]+"  ");
				}
			break;
		case 1:
			for(int i = 0; i<cities[1].length;i++) {
				System.out.print(cities[0][i]+"   ");
			}
			break;
		case 2:
			for(int i = 0; i<cities[2].length;i++) {
				System.out.print(cities[0][i]+"   ");
			}
			break;
		case 3:
			for(int i = 0; i<cities.length;i++) {
				for(int j = 0; j<cities[i].length;j++) {
				System.out.print(cities[i][j]+"   ");
			}
			}
			break;
		}
	}
	

请选择省份：0=吉林省，1=辽宁省，2=黑龙江省，3=全部
0
长春市  吉林市  四平市  通化市  

14. 实现一个简单的购物车添加商品的功能。

@Test
	public void work13() {
		System.out.println("欢迎光临吉吉便利店，请添加商品到购物车：");
		String[] ShopCart = {};
		for(int i = 0;i<1000;i++) {
		System.out.println("1=苹果；2=西瓜；3=葡萄；4=草莓；5=香蕉；6=查看购物车；7=退出");
		int num = new Scanner(System.in).nextInt();
		switch(num) {
		case 1:
			ShopCart=Arrays.copyOf(ShopCart, ShopCart.length+1);
			System.out.println("添加购物车成功!请继续添加");
			for(int j = ShopCart.length-1;j<ShopCart.length;j++) {
				ShopCart[j]="苹果";
				break;
			}
			break;
		case 2:
			ShopCart=Arrays.copyOf(ShopCart, ShopCart.length+1);
			System.out.println("添加购物车成功!请继续添加");
			for(int j = ShopCart.length-1;j<ShopCart.length;j++) {
				ShopCart[j]="西瓜";
				break;
			}
			break;
		case 3:
			ShopCart=Arrays.copyOf(ShopCart, ShopCart.length+1);
			System.out.println("添加购物车成功!请继续添加");
			for(int j = ShopCart.length-1;j<ShopCart.length;j++) {
				ShopCart[j]="葡萄";
				break;
			}
			break;
		case 4:
			ShopCart=Arrays.copyOf(ShopCart, ShopCart.length+1);
			System.out.println("添加购物车成功!请继续添加");
			for(int j = ShopCart.length-1;j<ShopCart.length;j++) {
				ShopCart[j]="草莓";
				break;
			}
			break;
		case 5:
			ShopCart=Arrays.copyOf(ShopCart, ShopCart.length+1);
			System.out.println("添加购物车成功!请继续添加");
			for(int j = ShopCart.length-1;j<ShopCart.length;j++) {
				ShopCart[j]="香蕉";
				break;
			}
			break;
		case 6:
			System.out.println("您购物车中的商品:");
			for(int j = 0;j<ShopCart.length;j++) {
					System.out.print(ShopCart[j]+"  ");	
				}
			System.out.println("");
			System.out.println("请继续添加!");
			break;
		case 7:
			i=1001;
			System.out.println("退出");
			break;
		}
		}
	}

欢迎光临吉吉便利店，请添加商品到购物车：
1=苹果；2=西瓜；3=葡萄；4=草莓；5=香蕉；6=查看购物车；7=退出
1
添加购物车成功!请继续添加
1=苹果；2=西瓜；3=葡萄；4=草莓；5=香蕉；6=查看购物车；7=退出
2
添加购物车成功!请继续添加
1=苹果；2=西瓜；3=葡萄；4=草莓；5=香蕉；6=查看购物车；7=退出
6
您购物车中的商品:
苹果  西瓜  
请继续添加!
1=苹果；2=西瓜；3=葡萄；4=草莓；5=香蕉；6=查看购物车；7=退出
3
添加购物车成功!请继续添加
1=苹果；2=西瓜；3=葡萄；4=草莓；5=香蕉；6=查看购物车；7=退出
7
退出

15. 输入1到100之间的任意整数，然后计算这些整数中每个数出现的次数。

例如：输入2，20，32，18，

           输出0--->1次，1---->1次，2---->3次，3---->1次，8---->1次

@Test
	//1.输入1到100之间的任意整数，然后计算这些整数中每个数出现的次数。
	public void work01() {
		int[] arr= {};
		System.out.println("请输入1-100以内的整数:");
		for(int i=0;i<5;i++) {
			Scanner sc= new Scanner(System.in);
			arr = Arrays.copyOf(arr, arr.length+1);
			arr[i]=sc.nextInt();
		}
		int[][] num = new int[10][2];  //存储个位数以及每个数的个数
		for (int i = 0; i < 10; i++) {
			num[i][0]=i;
		}
		int a = -1; //个位数
		int b = -1; //十位数
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]<10) {
			a=arr[i];
			}else if(arr[i]>=10) {
				a = arr[i]%10;
				b = arr[i]/10;
			}
			for (int j = 0; j < num.length; j++) {
				if(a==num[j][0]) {
					num[j][1]++;
				}if(b==num[j][0]) {
					num[j][1]++;
				}
			}
		}
		for (int j = 0; j < num.length; j++) {
			if(num[j][1]!=0){
			System.out.println(num[j][0]+"---->"+num[j][1]+"次");
			}
		}
		}
		

请输入1-100以内的整数:
98
58
78
12
3
1---->2次
2---->1次
3---->1次
5---->1次
7---->1次
8---->3次
9---->1次

16. 输入10个个位整数，去掉重复数字，并从小到大排序

public void work02() {
		int[] arr = new int[10];
		int chongfu = 0;
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入10个个位数：");
		for(int i=0;i<10;i++) {
			arr[i]=sc.nextInt();
		}
		System.out.println("用户输入的数字："+Arrays.toString(arr));
		Arrays.sort(arr);
		//将重复的数赋值为10 从小到大排序后 10会排序到最后
		for (int i = 0; i < arr.length-1; i++) {
			if( arr[i]==arr[i+1]) {
				arr[i]=10;
				chongfu++;
			}
			}
		Arrays.sort(arr);
		int[] arr2 = new int[arr.length-chongfu];
		for (int i = 0; i < arr2.length; i++) {
			arr2[i]=arr[i];
		}
		System.out.println("处理后的数字："+Arrays.toString(arr2));
		}

请输入10个个位数：
5
6
8
2
4
4
5
6
9
7
用户输入的数字：[5, 6, 8, 2, 4, 4, 5, 6, 9, 7]
处理后的数字：[2, 4, 5, 6, 7, 8, 9]

17. 有两个整数型数组，长度相同，输入数组各项，完成输入后，判断两个数组的每个数组位置的值是否相同，如果都相同，则输出true，反之则输出false

public void work03() {
		int[] arr = new int[5];
		int[] arr1 = new int[5];
		boolean isok = false;
		System.out.println("请输入第一个数组的元素");
		Scanner sc = new Scanner(System.in);
		for(int i = 0;i<arr.length;i++) {
			arr[i]=sc.nextInt();
		}
		System.out.println("请输入第二个数组的元素");
		Scanner sc1 = new Scanner(System.in);
		for(int i = 0;i<arr1.length;i++) {
			int num1 = sc.nextInt();
			arr1[i]=num1;
		}
		for(int i = 0;i<arr.length;i++) {
			if(arr[i]==arr1[i]) {
				isok = true;
			}else {
				isok = false;
				break;
			}
			}
		if(isok) {
			System.out.println("两个数组相同"+true);
		}else {
			System.out.println("两个数组不相同"+false);
		}
		}

请输入第一个数组的元素
5
6
4
8
98
请输入第二个数组的元素
78
45
36
25
5
两个数组不相同false




请输入第一个数组的元素
1
2
3
4
5
请输入第二个数组的元素
1
2
3
4
5
两个数组相同true

18. 手动输入一个长度为10的数组，判断数组中是否存在四个连续相等的数值，如果存在则输出true，反之输出false

public void work04() {
		int[] arr = new int[10];
		boolean isok = false;
		System.out.println("请输入10个数字：");
		Scanner sc = new Scanner(System.in);
		for(int i = 0;i<arr.length;i++) {
			arr[i]=sc.nextInt();
			}
		for(int i = 0;i<arr.length;i++) {
			if(i<(arr.length/2+2) && arr[i]==arr[i+1] 
					&& arr[i+1]==arr[i+2] && arr[i+2]==arr[i+3]) {
				isok = true;
				break;
			}else {
				isok = false;
			}
		}
		if(isok) {
			System.out.println("数组中有四个连续相等的数值"+true);
		}else {
			System.out.println("数组中没有四个连续相等的数值"+false);
		}
		}

请输入10个数字：
4
4
4
4
5
6
7
8
7
3
数组中有四个连续相等的数值true



请输入10个数字：
1
4
5
67
8
9
56
1
2
3
数组中没有四个连续相等的数值false

19. 手动输入两个数组，将两个数组整合成为一个数组，并由大到小进行排序。

public void work05() {
		int[] arr = new int[5];
		int[] arr1 = new int[5];
		int[] total = new int[10];
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入第一个数组的元素");
		for (int i = 0; i < arr.length; i++) {
			arr[i]=sc.nextInt();
		}
		System.out.println("第一个数组为："+Arrays.toString(arr));
		System.out.println("请输入第二个数组的元素");
		for (int i = 0; i < arr1.length; i++) {
			arr1[i]=sc.nextInt();
		}
		System.out.println("第二个数组为："+Arrays.toString(arr1));
		for (int i = 0; i < arr.length; i++) {
			total[i]=arr[i];
			total[arr.length+i]=arr1[i];
		}
		Arrays.sort(total);
		System.out.print("合并后的数组为：");
		for (int i = 0; i < total.length; i++) {
			System.out.print(total[total.length-1-i]+" ");
		}
	}

请输入第一个数组的元素
5
4
59
89
12
第一个数组为：[5, 4, 59, 89, 12]
请输入第二个数组的元素
36
52
45
26
78
第二个数组为：[36, 52, 45, 26, 78]
合并后的数组为：89 78 59 52 45 36 26 12 5 4