-
10-JavaSE基础巩固练习：综合练习、二维数组
JavaSE基础巩固综合练习
1、前言
- 目的：
- 复习Java编程知识，能够使用所学的知识解决问题，提升我们的编程能力。
- 涉及到的知识点：
- 变量、数组
- 运算符：基本运算符、关系运算符、逻辑运算符
- 程序流程控制：
- if、switch、for、while、死循环、循环嵌套
- 跳转关键字：
- break、continue、return
- 方法
- 键盘录入、随机数
- …
- 关于提升编程思维和编程能力的建议：
- 编程思维和编程能力不是一朝一夕形成的，需要时间的沉淀和大量练习。
- 具体措施：勤于练习代码、勤于思考、熟能生巧。
- 前期：先模仿；后期：再创新。
2、卖飞机票
-
需求：
- 机票价格按照淡季和旺季、头等舱和经济舱收费；
- 输入机票原价、月份和头等舱或经济舱；
- 按照如下规则计算机票价格：
- 旺季（5-10月份）头等舱9折，经济舱8.5折；
- 淡季（11月到来年4月份）头等舱7折，经济舱6.5折。
-
分析：
- 1、键盘录入机票原价、月份
- 2、先判断月份是旺季还是淡季
- 3、键盘录入舱位，再判断是头等舱还是经济舱
- 4、根据实际情况计算出最终价格
-
实现：
package com.app.comprehensive12; import java.util.Scanner; /** * 综合练习：卖飞机票 * 需求： * 机票价格按照淡季和旺季、头等舱和经济舱收费； * 输入机票原价、月份和头等舱或经济舱； * 按照如下规则计算机票价格： * 旺季（5-10月份）头等舱9折，经济舱8.5折； * 淡季（11月到来年4月份）头等舱7折，经济舱6.5折。 */ public class Test1 { public static void main(String[] args) { // 1、键盘录入机票原价、月份 Scanner sc = new Scanner(System.in); System.out.println("请您输入机票原价："); int ticketPrice = sc.nextInt(); System.out.println("请您输入月份："); int month = sc.nextInt(); System.out.println("请您选择舱位：" + "\n0.头等舱" + "\n1.经济舱"); int seat = sc.nextInt(); // 2、先判断月份是旺季还是淡季 if (month >= 5 && month <= 10) { // 旺季 // 3、最终判断是经济舱还是头等舱： // 如果是头等舱，机票原价打9折；如果是经济舱，机票原价打8.5折 ticketPrice = getTicketPrice(ticketPrice, seat, 0.9, 0.85); } else if ( (month >= 1 && month <= 4) || (month >= 11 && month <= 12) ){ // 淡季 // 3、最终判断是经济舱还是头等舱： // 如果是头等舱，机票原价打7折；如果是经济舱，机票原价打6.5折 ticketPrice = getTicketPrice(ticketPrice, seat, 0.7, 0.65); }else { System.out.println("sorry！您输入的是非法月份！"); } System.out.println("您成功购买了机票，共花费 " + ticketPrice + " 元。"); } /** * 抽取代码做成方法前要考虑的问题： * 1.我要干嘛？ 根据舱位和折扣来计算最终的机票价格 * 2.我干这件事，需要什么才能完成？ 机票原价、舱位、头等舱的折扣、经济舱的折扣 * 3.方法的调用处是否需要继续使用这个结果？ 需要 */ /** * 根据舱位计算出最终的机票价格 * * @param ticketPrice 机票原价 * @param seat 舱位 * @param v1 头等舱的折扣 * @param v2 经济舱的折扣 * @return 返回最终的机票价格 */ public static int getTicketPrice(int ticketPrice, int seat, double v1, double v2) { // 3、再判断是经济舱还是头等舱： if (seat == 0) { // 头等舱 // 4、根据实际情况计算出价格 ticketPrice = (int) (ticketPrice * v1); // 强转成int类型 } else if (seat == 1) { // 经济舱 ticketPrice = (int) (ticketPrice * v2); } else { System.out.println("sorry！没有这个舱位~"); } return ticketPrice; // 返回最终的机票价格 } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
请您输入机票原价： 1000 请您输入月份： 11 请您选择舱位： 0.头等舱 1.经济舱 0 您成功购买了机票，共花费 700 元。 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
3、找质数
-
需求：
- 判断 101~200之间有多少个素数，并输出所有素数。
-
实现：
package com.app.comprehensive12; import java.util.Scanner; /** * 综合练习：找质数 * 需求： * 判断 101 ~ 200 之间有多少个素数(质数)，并输出所有素数 */ public class Test2 { public static void main(String[] args) { // 1、从键盘录入两个整数，分别表示范围的起始和结束 Scanner sc = new Scanner(System.in); while (true) { System.out.println("请您输入一个数作为范围的起始："); int startNumber = sc.nextInt(); System.out.println("请您输入一个数作为范围的结束："); int endNumber = sc.nextInt(); // 2、判断是否为正整数 if (startNumber > 0 && endNumber > 0) { // 4、调用judgePrimeNumber方法，判断 startNumber 到 endNumber 这个范围之间有多少个质数，并这个范围内的所有质数 judgePrimeNumber(startNumber, endNumber); // 5、判断完startNumber~endNumber这个范围内的质数个数了，跳出死循环 break; } else { System.out.println("sorry！您输入的不是正整数！"); } } } /** * 6、判断质数的实现方法 * * @param startNumber 起始范围 * @param endNumber 结束范围 */ public static void judgePrimeNumber(int startNumber, int endNumber) { // a.定义count变量，用于统计质数的个数 int count = 0; // b.定义外循环：遍历 startNumber ~ endNumber 这个范围，依次得到这个范围的每一个数 for (int i = startNumber; i <= endNumber; i++) { // i: 依次表示循环中的每一个数 // (1) 标记思想：立一个flag，初始值为true（一开始就认为当前遍历这个数是质数） boolean flag = true; // (2) 定义内循环：遍历 2~i(遍历到的当前这个数) 这个范围，依次得到这个范围的每一个数 for (int j = 2; j < i; j++) { // a.看看 i 是否能被 2~i 这个范围内的所有数整除 if (i % j == 0) { // 能，则将flag值改为false（表示i不是质数） flag = false; // 跳出内循环，继续判断下一个数 break; } } // c.内循环结束，判断flag if (flag) { // 如果还为true，说明当前这个数是质数 // (1) 判断i是否为1 if (i == 1) { // a.为1，则提示：“数字1既不是质数，也不是合数” System.out.println("数字"+ i +"既不是质数，也不是合数"); }else { // b.不为1，则输出这个质数 System.out.println(i + "是质数~"); // c.开始统计质数的个数 count++; } } } // d.当外循环结束了，说明startNumber~endNumber这个范围已经将所有质数都统计完了，输出最终统计结果！ System.out.println(startNumber + "~" + endNumber + "这个范围内总共有" + count + "个质数！"); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
请您输入一个数作为范围的起始： 1 请您输入一个数作为范围的结束： 10 数字1既不是质数，也不是合数 2是质数~ 3是质数~ 5是质数~ 7是质数~ 1~10这个范围内总共有4个质数！ Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
请您输入一个数作为范围的起始： -12 请您输入一个数作为范围的结束： 100 sorry！您输入的不是正整数！ 请您输入一个数作为范围的起始： 101 请您输入一个数作为范围的结束： 200 101是质数~ 103是质数~ 107是质数~ 109是质数~ 113是质数~ 127是质数~ 131是质数~ 137是质数~ 139是质数~ 149是质数~ 151是质数~ 157是质数~ 163是质数~ 167是质数~ 173是质数~ 179是质数~ 181是质数~ 191是质数~ 193是质数~ 197是质数~ 199是质数~ 101~200这个范围内总共有21个质数！ Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
4、开发验证码
-
需求：
- 定义方法实现随机生成一个5位的验证码。
- 验证码格式：
- 长度为5
- 前四位是大写字母或者小写字母
- 最后一位是数字
-
分析：
- 在以后我们要在一堆没有什么规律的数据中随机抽取，可以先把这些数据放到数组当中，再随机抽取一个索引
- 1、大写字母和小写字母都放到数组当中
- 2、随机抽取4个字母：A ~ Z、a ~ z
- 3、随机抽取1个数字：0~9
-
实现：
package com.app.comprehensive12; import java.util.Random; /** * 综合练习：开发验证码 * 需求：定义方法实现随机生成一个5位的验证码 * 验证码格式： * 1、长度为5 * 2、前四位是大写或者小写字母 * 3、最后一位是数字 */ public class Test3 { public static void main(String[] args) { // 调用生成验证码的方法，接收返回结果 String code = createVerification(); System.out.println("验证码：" + code); } public static String createVerification() { // 1、大写字母和小写字母都放到数组中 // 定义一个长度为52的char类型的数组，用于存储26位小写字母和26位大写字母 char[] chs = new char[52]; // 定义for循环遍历数组，依次将大写字母和小写字母存储到数组中 for (int i = 0; i < chs.length; i++) { // i: 0 1 2 3 4...51 // 判断i是否小于等于25 if (i <= 25) { // 注意：此时只有当i=0~25时，才可进入该分支 // i小于等于25，此时开始添加小写字母存储到数组中 // ASCII码表 // 97 98 99 100...122: 这些数字代表小写字母: a~z // 因此，将这些数字强转成char类型之后，其实就是小写字母: a~z // 97 + i: 当i=0时，97+i=97；当i=1时，97+i=98...97+i=122 chs[i] = (char)(97 + i); }else { // 注意：此时只有当i>25时，才可进入该分支 // i大于25，此时开始添加大写字母存储到数组中 // ASCII码表 // 65 66 67 68...90: 这些数字代表大写字母: A~Z // 因此，将这些数字强转成char类型之后，其实就是大写字母: A~Z // 65 + i - 26: 当i=26时，65+i-26=65；当i=27时，65+i-26=66...65+i-26=90 chs[i] = (char)(65 + i - 26); } } // 定义一个字符串变量，用于记录最终5位验证码：4个字母+1个数字 String code = ""; // 2、随机抽取4个字母 // 创建随机数对象，用于生成随机数、随机索引 Random rd = new Random(); for (int i = 0; i < 4; i++) { // i: 0 1 2 3 // 随机生成一个索引 int randomIndex = rd.nextInt(chs.length); // 利用随机生成的索引，获取对应索引位置的元素，并记录到code变量中 code += chs[randomIndex]; // 等价于 code = code + chs[randomIndex] } // 3、随机抽取2个数字：0~9 // 随机生成一个数字 int randomNumber = rd.nextInt(10); // 将随机生成的数字，记录到code变量中 code += randomNumber; // 4、返回开发好的5位验证码 return code; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
验证码：Lqke4 Process finished with exit code 0- 1
- 2
- 3
- 4
验证码：LvqT8 Process finished with exit code 0- 1
- 2
- 3
- 4
5、数组元素的复制
-
需求：
- 将一个数组中的元素复制到另一个新数组中去。
-
分析：
- 假如原数组：[1, 2, 3, 4, 5]
- 复制到新数组：[1, 2, 3, 4, 5]
-
实现：
package com.app.comprehensive12; import java.util.Arrays; /** * 综合练习：数组元素的复制 * 需求： * 将一个数组中的元素复制到另一个新数组中 */ public class Test4 { public static void main(String[] args) { // 定义一个原数组，存储一批数据 int[] arr = {1, 33, 22, 5, 9}; // 遍历数组原数组的每一个元素 System.out.println("原数组：" + Arrays.toString(arr)); // 调用复制数组的方法，接收返回的新数组 int[] newArr = copyArray(arr); // 遍历输出新数组的每一个元素 System.out.println("新数组：" + Arrays.toString(newArr)); } /** * 定义拷贝数组的方法 * @param arr 接收一个数组 * @return 返回拷贝后的数组 */ public static int[] copyArray(int[] arr) { // 定义一个新数组，长度和原数组是一样的 int[] newArr = new int[arr.length]; // 遍历原数组，依次得到原数组中的每一个元素 for (int i = 0; i < arr.length; i++) { // 将原数组中的每一个元素赋值给新数组 newArr[i] = arr[i]; } // 当循环结束，拷贝完成，返回新数组 return newArr; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
原数组：[1, 33, 22, 5, 9] 新数组：[1, 33, 22, 5, 9] Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
6、评委打分
-
需求：
- 在唱歌比赛中，有6名评委给选手打分，分数范围是[0~100]之间的整数。选手的最后得分为：
- 去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。
- 在唱歌比赛中，有6名评委给选手打分，分数范围是[0~100]之间的整数。选手的最后得分为：
-
分析：
- 1、求最值
- 2、求总和
- 3、求平均分
-
实现：
package com.app.comprehensive12; import java.util.Scanner; /** * 综合练习：评委打分 * 需求： * 在唱歌比赛中，有6名评分给选手打分，分数范围是[0~100]之间的整数。 * 选手的最后得分为：去掉最高分、最低分的4个评委的平均分。 * 请完成上述过程并计算出选手的得分 */ public class Test5 { public static void main(String[] args) { // 1、调用获取6位评委打分后的数组（0~100） int[] scoreArr = getScoreArr(); System.out.print("\n6名评委的打分为："); for (int score : scoreArr) { System.out.print(score + " "); } // 2、求出数组中的最高分 int maxScore = getMaxScore(scoreArr); System.out.println("\n最高分：" + maxScore); // 3、求出数组中的最低分 int minScore = getMinScore(scoreArr); System.out.println("最低分：" + minScore); // 4、求出数组中所有分数的和 int sumScore = getSumScore(scoreArr); System.out.println("总分：" + sumScore); // 5、计算平均分：(总分 - 最高分 - 最低分) / 4 int averageScore = (sumScore - maxScore - minScore) / (scoreArr.length - 2); System.out.println("这位选手的最终得分是" + averageScore + "分！恭喜！~^_^~"); } /** * 求出数组中所有分数的和 * @param scoreArr 接收一个数组 * @return 返回分数总和 */ public static int getSumScore(int[] scoreArr) { // 1、定义sum变量，用于记录分数总和 int sum = 0; // 2、遍历数组，依次得到每一个分数 for (int i = 0; i < scoreArr.length; i++) { // 每遍历到一个分数，进行累加 sum += scoreArr[i]; } // 3、遍历结束，说明累加完成，返回总分 return sum; } /** * 求出数组中的最低分 * @param scoreArr 接收一个数组 * @return 将最低分返回 */ public static int getMinScore(int[] scoreArr) { // 1、将数组中的首元素设置为最低分，用于与其他元素作比较 int min = scoreArr[0]; // 2、遍历数组，依次得到每一个分数 for (int i = 0; i < scoreArr.length; i++) { // 判断当前遍历到的分数 是否小于 首元素 if (scoreArr[i] < min) { // 小于，则替换min的值 min = scoreArr[i]; } } // 3、循环结束，说明比完了，此时min里的值就是最低分，返回最低分 return min; } /** * 求出数组中的最高分 * @param scoreArr 接收一个数组 * @return 将最高分返回 */ public static int getMaxScore(int[] scoreArr) { // 1、将数组中的首元素设置为最大值，用于与其他元素作比较 int max = scoreArr[0]; // 2、遍历数组，依次得到每一个分数 for (int i = 0; i < scoreArr.length; i++) { // 判断当前遍历到的分数 是否大于 首元素 if (scoreArr[i] > max) { // 大于，则替换max的值 max = scoreArr[i]; } } // 3、循环结束，说明比完了，此时max里的值就是最高分，返回最高分 return max; } /** * 获取6位评委打分后的数组 * @return 返回存储好6位评分打分的数组 */ public static int[] getScoreArr() { // 1、定义一个数组，用于存储6位评委的打分 int[] scoreArr = new int[6]; // 2、创建键盘录入对象，用于评委打分 Scanner sc = new Scanner(System.in); // 3、6名评委开始打分 for (int i = 0; i < scoreArr.length;) { System.out.println("请第" + (i+1) +"位评委给选手打分："); int score = sc.nextInt(); // 判断打分的范围：0~100 if (score >= 0 && score <= 100) { // 打分在规定范围内，将此分数存储到数组中 scoreArr[i] = score; // i++: 让下一位评委进行打分 i++; }else { System.out.println("sorry！您的打分已超出规定范围0~100，请重新打分！"); } } // 4、循环结束，6名评委已全部完成打分，返回数组 return scoreArr; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
请第1位评委给选手打分： -12 sorry！您的打分已超出规定范围0~100，请重新打分！ 请第1位评委给选手打分： 100 请第2位评委给选手打分： 99 请第3位评委给选手打分： 89 请第4位评委给选手打分： 1234 sorry！您的打分已超出规定范围0~100，请重新打分！ 请第4位评委给选手打分： 66 请第5位评委给选手打分： 77 请第6位评委给选手打分： 88 6名评委的打分为：100 99 89 66 77 88 最高分：100 最低分：66 总分：519 这位选手的最终得分是88分！恭喜！~^_^~ Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
7、数字加密
-
需求：
-
某系统的数字密码（大于0），比如1983，采用加密方式进行传输。
-
规则如下：
-
先得到每位数，然后每位数都加上5，再对10求余，最后将所有数字反转，得到一串新数。
-
-
-
实现：
package com.app.comprehensive12; /** * 综合练习：数字加密 * 需求： * a.某系统的数字密码（大于0），比如1983，采用加密方式进行传输 * * 加密规则如下： * a.先得到每位数，每位数都加5 * b.每位数再对10求余 * c.最后将所有数字反转，得到一串新数 */ public class Test6 { public static void main(String[] args) { int password = 1983; // 定义某系统的密码 System.out.println("加密前的密码：" + password); // 1、调用密码加密的方法，传入一串整数密码，并接收返回的新密码(加密后) int encryptPassword = getEncryptPassword(password); if (encryptPassword == -1) { System.out.println("sorry！系统密码必须大于0~"); }else { System.out.println("加密后的密码：" + encryptPassword); } } /** * 2、密码加密 * * @param password 接收一个系统密码 * @return 返回加密后的密码 */ public static int getEncryptPassword(int password) { // a.如果系统密码小于等于0，则返回-1 if (password <= 0) { return -1; } // (1) 计算密码的个数，用作于存储每位密码的数组的长度 // 定义计数变量，用于统计密码的个数 int count = 0; // 用一个临时变量存储原密码，方便后续使用 int tempPassword = password; // 使用while循环计算密码的个数 while (password != 0) { // 假如密码：1983，循环不断除以10 password = password / 10; // 每除以10一次，就统计次数 count++; } // while循环结束，密码个数统计完成！ // (2) 定义一个数组，用于将密码中的每位数存储到数组中，长度就是密码的个数 int[] arr = new int[count]; // (3) 将密码中的每位数都存储到数组中 // 定义一个索引，这个索引的位置是数组的最后一位: 表示从数组最后一个位置往回添加 int index = arr.length - 1; while (tempPassword != 0) { // a.先从密码的右边得到每一位数 int ge = tempPassword % 10; // b.再去掉右边的那位数 tempPassword = tempPassword / 10; // c.把获取到的每一位数添加到数组中 // 数组名[索引] = 每一位数; arr[index] = ge; // 每添加一位数，让索引位置往回移动一位 index--; } // while循环结束，说明密码的每位数都已成功添加到数组中了！ // (4) 密码加密 // 假如int[] arr: 1 9 8 3 // a.先得到密码的每一位数，都加5 for (int i = 0; i < arr.length; i++) { arr[i] = arr[i] + 5; } // 此时int[] arr: 6 14 13 8 // b.再将每一位数对10求余 for (int i = 0; i < arr.length; i++) { arr[i] = arr[i] % 10; } // 此时int[] arr: 6 4 3 8 // c.最后将所有数进行反转 for (int i = 0, j = arr.length - 1; i < j; i++, j--) { // 开始不断交换位置: // 先用临时变量将当前遍历到的数存储起来 int temp = arr[i]; // 将后一位的数 赋值给 前一位的数的位置 arr[i] = arr[j]; // 将前一位的数 赋值给 后一位的数的位置 arr[j] = temp; } // 循环结束，说明数组中所有的数已经完成了反转 // 此时int[] arr: 8 3 4 6 // d.将这些数从数组中拿出来，拼接成一串数字，返回给调用处 // 定义整数变量，用于拼接每一位反转后的每一位数字，得到最终加密的密码 int encryptPassword = 0; for (int i = 0; i < arr.length; i++) { // 不断拼接 encryptPassword = encryptPassword * 10 + arr[i]; } // 循环结束，说明拼接完成，返回最终加密后的密码 return encryptPassword; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
加密前的密码：1983 加密后的密码：8346 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
8、数字解密
-
需求：
- 请将上一个练习加密后的数据解密出来。
-
实现：
package com.app.comprehensive12; /** * 综合练习：数字加密、解密 * 需求： * a.某系统的数字密码（大于0），比如1983，采用加密方式进行传输 * * 加密规则如下： * a.先得到每位数，每位数都加5 * b.每位数再对10求余 * c.最后将所有数字反转，得到一串新数 * * 解密规则就是将加密规则反过来： * a.先将所有数字反转，得到一串新数 * b.如果数字是0~4之间，那就+10；如果数字是5~9之间，数字不变。（与加密规则不同的地方） * c.最后将每位数字都减5 */ public class Test6 { public static void main(String[] args) { int password = 1983; // 定义某系统的密码 System.out.println("加密前的密码：" + password); // 1、调用密码加密的方法，传入一串整数密码，并接收返回的新密码(加密后) int encryptPassword = getEncryptPassword(password); if (encryptPassword == -1) { System.out.println("sorry！系统密码必须大于0~"); }else { System.out.println("加密后的密码：" + encryptPassword); } // 3、调用密码解密的方法，传入加密后的密码，并接收返回的新密码(解密后) int decodePassword = getDecodePassword(encryptPassword); if (decodePassword == -1) { System.out.println("sorry！系统密码必须大于0~"); }else { System.out.println("解密后的密码：" + decodePassword); } } /** * 4、密码解密 * @param encryptPassword 接收一个加密后的密码 * @return 返回解密后的密码 */ public static int getDecodePassword(int encryptPassword) { // a.如果系统密码小于等于0，则返回null if (encryptPassword <= 0) { return -1; } // (1) 计算密码的个数，用作于存储每位密码的数组的长度 // 定义计数变量，用于统计密码的个数 int count = 0; // 用一个临时变量存储原密码，方便后续使用 int tempPassword = encryptPassword; // 使用while循环计算密码的个数 while (encryptPassword != 0) { // 假如密码：12345，循环不断除以10 encryptPassword = encryptPassword / 10; // 每除以10一次，就统计次数 count++; } // while循环结束，密码个数统计完成！ // (2) 定义一个数组，用于将密码中的每位数存储到数组中，长度就是密码的个数 int[] arr = new int[count]; // (3) 将密码中的每位数都存储到数组中 // 定义一个索引，这个索引的位置是数组的最后一位: 表示从数组最后一个位置往回添加 int index = arr.length - 1; while (tempPassword != 0) { // a.先从密码的右边得到每一位数 int ge = tempPassword % 10; // b.再去掉右边的那位数 tempPassword = tempPassword / 10; // c.把获取到的每一位数添加到数组中 // 数组名[索引] = 每一位数; arr[index] = ge; // 每添加一位数，让索引位置往回移动一位 index--; } // while循环结束，说明密码的每位数都已成功添加到数组中了！ // (4) 密码解密 // 假如int[] arr: 8 3 4 6 // a.最后将所有数进行反转 for (int i = 0, j = arr.length - 1; i < j; i++, j--) { // 开始不断交换位置: // 先用临时变量将当前遍历到的数存储起来 int temp = arr[i]; // 将后一位的数 赋值给 前一位的数的位置 arr[i] = arr[j]; // 将前一位的数 赋值给 后一位的数的位置 arr[j] = temp; } // 循环结束，说明数组中所有的数已经完成了反转 // 此时int[] arr: 6 4 3 8 // b.如果数字是0~4之间，那就+10；如果数字是5~9之间，数字不变 for (int i = 0; i < arr.length; i++) { if (arr[i] >= 0 && arr[i] <= 4) { arr[i] += 10; } // 如果数字是5~9之间，就不进入上面的if判断，数字保持不变的存入数组中 } // 此时int[] arr: 6 14 13 8 // c.先得到密码的每一位数，都减5 for (int i = 0; i < arr.length; i++) { arr[i] -= 5; } // 此时int[] arr: 1 9 8 3 // d.将这些数从数组中拿出来，拼接成一串数字，返回给调用处 // 定义整数变量，用于拼接每一位反转后的每一位数字，得到最终加密的密码 int decodePassword = 0; for (int i = 0; i < arr.length; i++) { decodePassword = decodePassword * 10 + arr[i]; } // 循环结束，说明拼接完成，返回最终加密后的密码 return decodePassword; } /** * 2、密码加密 * * @param password 接收一个系统密码 * @return 返回加密后的密码 */ public static int getEncryptPassword(int password) { // a.如果系统密码小于等于0，则返回-1 if (password <= 0) { return -1; } // (1) 计算密码的个数，用作于存储每位密码的数组的长度 // 定义计数变量，用于统计密码的个数 int count = 0; // 用一个临时变量存储原密码，方便后续使用 int tempPassword = password; // 使用while循环计算密码的个数 while (password != 0) { // 假如密码：1983，循环不断除以10 password = password / 10; // 每除以10一次，就统计次数 count++; } // while循环结束，密码个数统计完成！ // (2) 定义一个数组，用于将密码中的每位数存储到数组中，长度就是密码的个数 int[] arr = new int[count]; // (3) 将密码中的每位数都存储到数组中 // 定义一个索引，这个索引的位置是数组的最后一位: 表示从数组最后一个位置往回添加 int index = arr.length - 1; while (tempPassword != 0) { // a.先从密码的右边得到每一位数 int ge = tempPassword % 10; // b.再去掉右边的那位数 tempPassword = tempPassword / 10; // c.把获取到的每一位数添加到数组中 // 数组名[索引] = 每一位数; arr[index] = ge; // 每添加一位数，让索引位置往回移动一位 index--; } // while循环结束，说明密码的每位数都已成功添加到数组中了！ // (4) 密码加密 // 假如int[] arr: 1 9 8 3 // a.先得到密码的每一位数，都加5 for (int i = 0; i < arr.length; i++) { arr[i] = arr[i] + 5; } // 此时int[] arr: 6 14 13 8 // b.再将每一位数对10求余 for (int i = 0; i < arr.length; i++) { arr[i] = arr[i] % 10; } // 此时int[] arr: 6 4 3 8 // c.最后将所有数进行反转 for (int i = 0, j = arr.length - 1; i < j; i++, j--) { // 开始不断交换位置: // 先用临时变量将当前遍历到的数存储起来 int temp = arr[i]; // 将后一位的数 赋值给 前一位的数的位置 arr[i] = arr[j]; // 将前一位的数 赋值给 后一位的数的位置 arr[j] = temp; } // 循环结束，说明数组中所有的数已经完成了反转 // 此时int[] arr: 8 3 4 6 // d.将这些数从数组中拿出来，拼接成一串数字，返回给调用处 // 定义整数变量，用于拼接每一位反转后的每一位数字，得到最终加密的密码 int encryptPassword = 0; for (int i = 0; i < arr.length; i++) { // 不断拼接 encryptPassword = encryptPassword * 10 + arr[i]; } // 循环结束，说明拼接完成，返回最终加密后的密码 return encryptPassword; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
加密前的密码：1983 加密后的密码：8346 解密后的密码：1983 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
9、抢红包
-
需求：
- 一个大V直接抽奖，奖品是现金红包，分别有{2, 588, 888, 1000, 10000}五个奖金。
- 请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
- 打印效果如下：（随机顺序，不一定是下面的顺序）
-
实现：
-
方式1：
package com.app.comprehensive12; import java.util.Random; /* 综合练习：抢红包 方式1 需求： 一个大V直接抽奖，奖品是现金红包，分别有{2, 588, 888, 1000, 10000}五个奖金。 请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。 打印效果比如：（随机顺序，不一定是下面的顺序，多运行几次） 888元的奖金被抽出 588元的奖金被抽出 10000元的奖金被抽出 1000元的奖金被抽出 2元的奖金被抽出 */ public class Test7 { public static void main(String[] args) { // 1、定义数组，用于存储奖池红包数据 int[] jackpotArr = {2, 588, 888, 1000, 10000}; // 2、调用抢红包的方法，传入jackpotArr数组 redWars(jackpotArr); } /** * 抢红包 * @param jackpotArr 接收奖池数组 */ public static void redWars(int[] jackpotArr) { // 1、传入的数组如果为null if (jackpotArr == null) { System.out.println("数组不能为null！"); return; } // 2、定义数组，用于存储抽到的红包数据 int[] awardArr = new int[jackpotArr.length]; // 3、抽奖 // 创建随机数对象 Random rd = new Random(); for (int i = 0; i < jackpotArr.length;) { // 生成一个随机索引 int randomIndex = rd.nextInt(jackpotArr.length); // 随机抽取到的奖项 int award = jackpotArr[randomIndex]; // 调用contains方法判断award是否存在于awardArr中 boolean flag = contains(awardArr, award); // 如果award不存在于awardArr中，就将该数据添加进去 if (!flag) { awardArr[i] = award; // 添加完毕后，让索引往后移动一个位置 i++; } // 如果不进入上面的if判断，说明award存在于awardArr中，那就继续 } // 循环结束，抽奖完成，输出 for (int award : awardArr) { System.out.println(award + "元的奖金被抽出~"); } } /** * 判断传入的奖励数据是否存在于awardArr(奖励数据数组)中 * @param awardArr 奖励数据的数组 * @param award 奖励数据 * @return 存在返回true，不存在返回false */ public static boolean contains(int[] awardArr, int award) { // 遍历奖励数据的数组，依次得到每一个奖励数据 for (int i = 0; i < awardArr.length; i++) { // 判断award是否存在于awardArr数组中 if (award == awardArr[i]) { // 存在，返回true return true; } } // 循环结束，仍然找不到，说明不存在，返回false return false; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
10000元的奖金被抽出~ 888元的奖金被抽出~ 2元的奖金被抽出~ 1000元的奖金被抽出~ 588元的奖金被抽出~ Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
-
方式2：
package com.app.comprehensive12; import java.util.Random; /* 综合练习：抢红包 随机抽奖的方式2：打乱顺序 */ public class Test8 { public static void main(String[] args) { // 定义奖池数组，存入红包数据 int[] arr = {1, 100, 200, 300, 488, 10000}; // 创建随机数对象，用于生成随机数 Random rd = new Random(); // 随机抽奖 for (int i = 0; i < arr.length; i++) { // 随机生成一个索引 int randomIndex = rd.nextInt(arr.length); // 不断交换位置(打乱顺序) int temp = arr[i]; arr[i] = arr[randomIndex]; arr[randomIndex] = temp; } // 遍历输出 for (int a : arr) { System.out.println(a + "元的奖金被抽出~"); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
10000元的奖金被抽出~ 488元的奖金被抽出~ 200元的奖金被抽出~ 1元的奖金被抽出~ 300元的奖金被抽出~ 100元的奖金被抽出~ Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
-
10、双色球系统
-
需求：
-
投注号码由6个红色球号码和1个蓝色球号码组成
-
红色球号码从133中选择；蓝色球号码从116中选择。
-
-
实现：
package com.app.comprehensive12; import java.util.Random; import java.util.Scanner; /* 综合练习：双色球系统 需求： 投注号码由6个红色球号码和1个蓝色球号码组成； 红色球号码从1~33中选择； 蓝色球号码从1~16中选择。 */ public class Test9 { public static void main(String[] args) { // 1、调用生成号码的方法，生成中奖号码：6个红色球+1个蓝色球 int[] numberArr = createNumbers(); System.out.println("================================"); System.out.println("本期双色球号码："); queryNumbers(numberArr); System.out.println("================================"); // 2、调用用户选号的方法，让用户输入自己要买的号码：6个红色球+1个蓝色球 int[] userInputArr = userInputNumbers(); System.out.println("----------------------------"); System.out.println("您选的双色球号码："); queryNumbers(userInputArr); System.out.println("----------------------------\n"); // 3、调用判断用户中奖情况的方法，输出用户中奖情况 judgeUserAward(numberArr, userInputArr); } /** * 判断用户中奖情况 * * @param numberArr 本期双色球号码数组 * @param userInputArr 用户选的双色球号码数组 */ public static void judgeUserAward(int[] numberArr, int[] userInputArr) { // 1、定义两个变量，分别用于统计用户的红色球、蓝色球的中奖数量 int redCount = 0; int blueCount = 0; // 2、统计用户选的红色球号码中了多少个 // 先在外部遍历用户选的双色球号码数组，依次得到每个号码 for (int i = 0; i < userInputArr.length - 1; i++) { int redNumber = userInputArr[i]; // 然后再内部遍历本期双色球号码数组，依次得到每个号码 for (int j = 0; j < numberArr.length - 1; j++) { // 判断当前用户选的红色球号码 是否与 本期红色球号码 if (redNumber == numberArr[j]) { // 相等，说明中奖了，开始统计红色球中奖号码的个数 redCount++; // 既然已经中奖了，那就不需要一一和后面的号码做比较了 // 直接跳出内部循环，继续判断用户的下一个红色球号码是否中奖 break; } } } // 循环结束，说明用户的红色球号码的中奖数量已经统计完了 // 3、判断用户选的蓝色球号码是否中奖 if (userInputArr[userInputArr.length - 1] == numberArr[numberArr.length - 1]) { // 中奖，开始统计蓝色球中奖号码的个数 blueCount++; } System.out.println("红色球中奖：" + redCount + "个"); System.out.println("蓝色球中奖：" + blueCount + "个"); // 4、判断中奖情况，输出中奖的级别及奖金 if (redCount == 6 && blueCount == 1) { // 一等奖：中6个红球+1个蓝球 System.out.println("恭喜您，中了一等奖，1000万元已到账~"); } else if (redCount == 6 && blueCount == 0) { // 二等奖：中6个红球+0个蓝球 System.out.println("恭喜您，中了二等奖，500万元已到账~"); } else if (redCount == 5 && blueCount == 1) { // 三等奖：中5个红球+1个蓝球 System.out.println("恭喜您，中了三等奖，3000元已到账~"); } else if ((redCount == 5 && blueCount == 0) || (redCount == 4 && blueCount == 1)) { // 四等奖：中5个红球+0个蓝球 或 中4个红球+1个蓝球 System.out.println("恭喜您，中了四等奖，200元已到账~"); } else if ((redCount == 4 && blueCount == 0) || (redCount == 3 && blueCount == 1)) { // 五等奖：中4个红球+0个蓝球 或 中3个红球+1个蓝球 System.out.println("恭喜您，中了五等奖，10元已到账~"); } else if ( // 六等奖：中2个红球+1个蓝球 或 中1个红球+1个蓝球 或 中0个红球+1个蓝球 (redCount == 2 && blueCount == 1) || (redCount == 1 && blueCount == 1) || (redCount == 0 && blueCount == 1) ) { System.out.println("恭喜您，中了六等奖，5元已到账~"); }else { // 没中奖 System.out.println("谢谢惠顾~ 欢迎下次光临！！^_^"); } } /** * 查询所有双色球号码 * * @param numberArr 接收一个数组 */ public static void queryNumbers(int[] numberArr) { // 遍历双色球号码数组 for (int i = 0; i < numberArr.length; i++) { // 如果是前6个，则说明是红色球号码，则输出：颜色+号码，并使用空格隔开 if (i >= 0 && i <= 5) { System.out.print("红" + numberArr[i] + " "); } else { // 如果是最后一个，则说明是蓝色球号码，则输出：颜色+号码 System.out.println("蓝" + numberArr[i]); } } } /** * 用户选号 * * @return 将存储有用户选号的数组返回 */ public static int[] userInputNumbers() { // 1、定义数组用于存储用户选号的双色球号码：6个红色球+1个蓝色球 int[] userInputArr = new int[7]; // 2、用户选择6个红色球号码 // 创建键盘录入对象，用于从键盘录入数据 Scanner sc = new Scanner(System.in); for (int i = 0; i < 6; ) { // 用户开始选择红色球号码 System.out.println("请您选择第" + (i + 1) + "个红色球号码："); int redNumber = sc.nextInt(); // 判断用户选的号码是否超出了红色球号码范围 if (redNumber >= 1 && redNumber <= 33) { // 没超出，则判断用户当前选的号码是否与选过的号码重复 boolean flag = contains(userInputArr, redNumber); if (!flag) { // 没重复，则将用户的选号添加到数组中 userInputArr[i] = redNumber; // 添加完成后，让索引位置往后移一位 i++; } else { System.out.println("sorry！您选的红色球号码已经选过了！请您重新选择~"); } } else { // 已超出 System.out.println("sorry！您选的红色球号码已超出红色球号码规定范围！请您重新选择~ ^_^~"); } } // 3、用户选择1个蓝色球号码 while (true) { System.out.println("请您选择蓝色球号码："); int blueNumber = sc.nextInt(); // 判断用户选的号码是否超出了蓝色球号码范围 if (blueNumber >= 1 && blueNumber <= 16) { // 没超出，则将用户的选号添加到数组中的末尾 userInputArr[userInputArr.length - 1] = blueNumber; // 添加完成后，跳出死循环 break; }else { System.out.println("sorry！您选的蓝色球号码已超出蓝色球号码规定范围！请您重新选择~ ^_^~"); } } // 循环结束，说明用户选号完成。 // 4、返回数组 return userInputArr; } /** * 生成中奖号码 * * @return 将存储有中奖号码的数组返回 */ public static int[] createNumbers() { // 1、定义数组用于存储生成好的中奖号码 // 蓝色球号码6个 + 红色球号码1个 int[] numberArr = new int[7]; // 2、生成6个红色球号码 // 创建随机数对象，用于生成随机数 Random rd = new Random(); for (int i = 0; i < 6; ) { // 随机生成一个1~33范围的红色球号码 // 唯一不重复：不能与其他红色球号码重复！！ int redNumber = rd.nextInt(33) + 1; // 调用contains方法判断数组中是否已存在该红色球号码 boolean flag = contains(numberArr, redNumber); if (!flag) { // 不存在，则添加该红色球号码到数组中 numberArr[i] = redNumber; // 添加完成后，让索引往后移动一位 i++; } // 如果程序不进入上面的if，说明该红色球号码存在于数组中 // 则索引位置还是处于当前位置不变，重新随机生成一个1~33范围的红色球号码 } // 循环结束，说明6个红色球号码已全部生成好了！ // 3、生成1个蓝色球号码 // 随机生成一个1~16范围的蓝色球号码 int blueNumber = rd.nextInt(16) + 1; // 将这个蓝色球号码添加到数组的末尾 numberArr[numberArr.length - 1] = blueNumber; // 4、6个红色球号码 + 1蓝色球号码 已全部生成好了！返回该数组 return numberArr; } /** * 查询数组中是否存在指定元素 * * @param arr 接收一个数组 * @param number 接收一个指定元素 * @return 存在返回true，不存在返回false */ public static boolean contains(int[] arr, int number) { // 遍历数组，依次得到数组中的每一个元素 for (int i = 0; i < arr.length; i++) { // 判断该元素是否与其他元素相等 if (number == arr[i]) { // 相等，返回true return true; } } // 循环结束，说明该元素与其他元素不相等，返回false return false; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
================================ 本期双色球号码： 红12 红9 红11 红33 红10 红29 蓝15 ================================ 请您选择第1个红色球号码： 12 请您选择第2个红色球号码： 33 请您选择第3个红色球号码： 9 请您选择第4个红色球号码： 10 请您选择第5个红色球号码： 29 请您选择第6个红色球号码： 11 请您选择蓝色球号码： 15 ---------------------------- 您选的双色球号码： 红12 红33 红9 红10 红29 红11 蓝15 ---------------------------- 红色球中奖：6个 蓝色球中奖：1个 恭喜您，中了一等奖，1000万元已到账~ Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
11、二维数组
（1）什么是二维数组？
-
二维数组：
数组中的数组- 就是将很多个一维数组放到一个大的数组当中，方便管理，也叫
二维数组。
-
我们之前学的都是一维数组：
（2）二维数组的应用场景？
- 当我们需要把数据进行分组管理的时候，就需要用到二维数组。
- 举例：
- 某商城每个季度的营业额如下：单位(万元)
- 第一季度：22,66,44
- 第二季度：77,33,88
- 第三季度：25,45,65
- 第四季度：11,66,99
- 要求计算出每个季度的总营业额和全年的总营业额
- 分析：
- 要把每个季度都分别使用一维数组，再用一个大的数组将这些季度都装起来，这就是二维数组的应用场景。
- 某商城每个季度的营业额如下：单位(万元)
（3）二维数组的初始化
a.静态初始化
-
格式：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2}, {元素1,元素2},...};- 1
-
范例：
int[][] arr = new int[][]{{11,22}, {33,44}};- 1
-
简化格式(常用)：
数据类型[][] 数组名 = {{元素1,元素2}, {元素1,元素2},...};- 1
-
范例1(常用)：
int[][] arr = {{11,22}, {33,44}};- 1
-
范例2：
int arr[][] = {{11,22}, {33,44}};- 1
package com.app.demo13_tow_array; /* 目标：学习二维数组的静态初始化、遍历二维数组 二维数组： 数组中的数组； 一个大的数组里，装着多个一维数组 */ public class TowArrayDemo1 { public static void main(String[] args) { // 1、二维数组静态初始化的格式 // 数据类型[][] 数组名 = new 数据类型[][]{{元素1, 元素2}, {元素1, 元素2}}; // 格式1 int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5, 6, 7, 8}}; // 格式2 int[][] arr2 = {{1, 2, 3}, {4, 5, 6, 7, 8}}; // 格式3 // 建议这样定义，把每一个一位数组单独写成一行 // 注意：每一个一维数组其实是二维数组中的元素，所以每一个一维数组之间需要用逗号隔开。 // 最后一个数组后面不需要加逗号，与一维数组同理。 int[][] arr3 = { {1, 2, 3}, {4, 5, 6, 7, 8} }; // 2、获取元素 /* arr[i][j] arr: 二维数组 i: 二维数组的索引，获取出来的是里面的一维数组 j: 表示一维数组中的索引，获取出来的是真正的元素 */ System.out.println(arr3[0]); // 表示获取二维数组中的第一个一维数组的内存地址 // 打印元素1 // arr3[0]: 二维数组中的第一个一维数组 // arr3[0][0]: 获取第一个一维数组0索引的元素 System.out.println(arr3[0][0]); // 打印元素7 // arr3[1]: 二维数组中的第二个一维数组 // arr3[1][3]: 获取第二个一维数组3索引的元素 System.out.println(arr3[1][3]); // 超出了二维数组的长度范围 // System.out.println(arr3[2]); // 报错：ArrayIndexOutOfBoundsException System.out.println("------------------------------"); // 3、遍历二维数组 // 思想：先获取到一维数组，再遍历一维数组获取元素 // 外循环：遍历二维数组，依次得到里面的每一个一维数组 for (int i = 0; i < arr3.length; i++) { // 先遍历获取到一维数组 // i: 表示二维数组中的每一个索引 // arr3[i]: 表示二维数组中的每一个元素(一维数组) // 内循环：遍历一维数组，依次得到里面的每一个元素 for (int j = 0; j < arr3[i].length; j++) { // 再遍历一维数组获取元素 // j: 一维数组中的每一个元素 System.out.print(arr3[i][j] + " "); } // 内循环结束，说明遍历完了一个一维数组的元素，打印换行，接着打印下一个一维数组的元素 System.out.println(); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
[I@119d7047 1 7 ------------------------------ 1 2 3 4 5 6 7 8 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
b.动态初始化
-
格式：
数据类型[][] 数组名 = new 数据类型[m][n];- 1
-
m：表示二维数组的长度（二维数组可以存放多少个一维数组） -
n：表示一维数组的长度（一维数组可以存放多少个元素） -
范例：
int[][] arr = new int[2][3];- 1
- 该二维数组可以存放
2个一维数组，每一个一维数组中可以存放3个int类型的元素。
package com.app.demo13_tow_array; /* 目标：学习二维数组的动态初始化、遍历二维数组 */ public class TowArrayDemo2 { public static void main(String[] args) { // 1、动态初始化一个二维数组 /* 6: 表示二维数组的长度，可以存在6个一维数组 6: 表示一维数组的长度，每个一维数组可以存放6个int类型的元素 */ int[][] arr = new int[6][6]; // 2、添加元素 arr[0][0] = 66; // 3、遍历二维数组 // 外循环：遍历二维数组，依次得到每个一维数组 for (int i = 0; i < arr.length; i++) { // 内循环：遍历一维数组，依次得到每个元素 for (int j = 0; j < arr[i].length; j++) { System.out.print(j == arr[i].length - 1 ? arr[i][j] : arr[i][j] + " "); } // 当内循环结束，说明已经遍历完一个一维数组，打印一个换行 System.out.println(); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
66 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
（4）二维数组的内存图
-
特殊情况一：（了解）
- 好处就是，二维数组中的一维数组，我们可以自己定义一维数组的长度，这样比较灵活。
-
特殊情况二：（了解）
总结
1、什么时候使用二维数组呢？
- 当我们需要把数据分组管理的时候，就需要用到二维数组。
2、关于二维数组我们需要掌握什么？
- 掌握二维数组的静态初始化、动态初始化。
3、如何给二维数组中的元素赋值？
-
格式：
数组名[索引] = 值; // 给二维数组中的元素赋值 数组名[索引][索引] = 值; // 给二维数组中的一维数组赋值- 1
- 2
4、如何遍历二维数组？
- 先遍历二维数组，依次得到每个一维数组；
- 再依次遍历每个一维数组，依次得到每个元素。
（5）二维数组的练习
-
场景：
- 某商城每个季度的营业额如下：单位(万元)
- 第一季度：22,66,44
- 第二季度：77,33,88
- 第三季度：25,45,65
- 第四季度：11,66,99
- 某商城每个季度的营业额如下：单位(万元)
-
需求：
- 要求计算出每个季度的总营业额和全年的总营业额。
-
分析：
- 可以看到，每个季度都有多个营业额，而营业额又不止一个，营业额的个数又是相等。
-
实现：
-
静态初始化二维数组的方式实现：
package com.app.demo13_tow_array; /* 二维数组的练习： 静态初始化二维数组： 计算每个季度的总营业额和全年的总营业额。 第一个季度：22,66,44 一维数组 第二个季度：77,33,88 一维数组 第三个季度：25,45,65 一维数组 第四个季度：11,66,99 一维数组 */ public class TowArrayTest3 { public static void main(String[] args) { // 1、静态初始化一个二维数组，分别存入四个季度的营业额 int[][] yearArr = { {22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99} }; // 2、调用计算每个季度的营业额和的方法 // 方式1：不推荐 /*int oneSum = getSum(yearArr[0]); int towSum = getSum(yearArr[1]); int threeSum = getSum(yearArr[2]); int fourSum = getSum(yearArr[3]); System.out.println("第一季度的营业额的总和：" + oneSum + "万元"); System.out.println("第二季度的营业额的总和：" + towSum + "万元"); System.out.println("第三季度的营业额的总和：" + threeSum + "万元"); System.out.println("第四季度的营业额的总和：" + fourSum + "万元"); // 计算全年的总营业额 int yearSum = oneSum + towSum + threeSum + fourSum; System.out.println("全年的总营业额为：" + yearSum + "万元~"); */ // 定义变量，用于统计全年的总营业额 int yearSum = 0; // 方式2：推荐 for (int i = 0; i < yearArr.length; i++) { // yearArr[i]: 表示依次得到的季度数组(一维数组) // 定义一个数组，接收一下当前遍历到的一维数组 int[] quarterArr = yearArr[i]; // 将当前季度的数组传入getSum方法中，计算每个季度的总营业额 int sum = getSum(quarterArr); System.out.println("第" + (i+1) + "个季度的总营业额为：" + sum + "万元~"); // 计算全年的总营业额 yearSum += sum; } System.out.println("全年的总营业额为：" + yearSum + "万元~"); } /** * 计算每个季度的营业额总和 * @param arr 接收一个季度的营业额的数组 * @return 将当前季度的营业额总和返回 */ public static int getSum(int[] arr) { // 1、定义变量，用于统计季度营业额的和 int sum = 0; // 2、遍历数组，依次得到每个营业额 for (int i = 0; i < arr.length; i++) { // 累加季度营业额的和 sum += arr[i]; } // 3、循环结束，说明统计完成，返回总和 return sum; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
第1个季度的总营业额为：132万元~ 第2个季度的总营业额为：198万元~ 第3个季度的总营业额为：135万元~ 第4个季度的总营业额为：176万元~ 全年的总营业额为：641万元~ Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
-
动态初始化二维数组的方式实现：
package com.app.demo13_tow_array; import java.util.Scanner; /* 二维数组的练习： 动态初始化二维数组： 计算每个季度的总营业额和全年的总营业额。 第一个季度：22,66,44 一维数组 第二个季度：77,33,88 一维数组 第三个季度：25,45,65 一维数组 第四个季度：11,66,99 一维数组 */ public class TowArrayTest3Plus { public static void main(String[] args) { // 1、键盘录入各个季度的营业额 int[][] yearArr = getYearArr(4, 3); // 2、查看一下各个季度的营业额 System.out.println("查看所有季度的营业额："); queryQuarterTurnover(yearArr); System.out.println("-------------------------------------"); // 3、计算各个季度的总营业额和全年营业额 sumQuaterTurnoverAndYearTurnover(yearArr); } /** * 计算总营业额 * * @param yearArr 各个季度的营业额的二维数组 */ public static void sumQuaterTurnoverAndYearTurnover(int[][] yearArr) { // 1、定义两个变量，分别用于统计各个季度的总营业额、全年的总营业额 int yearSum = 0; int quarterSum = 0; // 2、遍历二维数组，依次得到每个季度的营业额数组 for (int i = 0; i < yearArr.length; i++) { // yearArr[i]: 表示每个季度的营业额数组 // 定义变量，接收每个季度的营业额数组 int[] quarterArr = yearArr[i]; // 调用getQuarterSum方法，计算每个季度的总营业额 quarterSum = getQuarterSum(quarterArr); System.out.println("第" + (i+1) + "季度的总营业额为：" + quarterSum + "万元"); // 计算全年的总营业额: 循环依次累加各个季度的总营业额 yearSum += quarterSum; } // 3、循环结束，全年的总营业额统计完毕 System.out.println("全年的总营业额为：" + yearSum + "万元"); } /** * 计算各个季度的总营业额 * @param quarterArr 各个季度的营业额数组 * @return 返回各个季度的总营业额 */ public static int getQuarterSum(int[] quarterArr) { // 1、定义变量，用于统计各个季度的总营业额 int quarterSum = 0; // 2、遍历各个季度的营业额数组 for (int i = 0; i < quarterArr.length; i++) { // 循环依次累加营业额 quarterSum += quarterArr[i]; } // 3、循环结束，统计完毕，返回各个季度的总营业额 return quarterSum; } /** * 键盘录入各个季度的营业额 * * @param oneDimensionalArrayLength 表示二维数组的长度：可以存放指定数量的一维数组 * @param towDimensionalArrayLength 表示一位数组的长度：可以存放指定数量的int类型的元素 * @return 返回各个季度的营业额的数组 */ public static int[][] getYearArr(int oneDimensionalArrayLength, int towDimensionalArrayLength) { // 1、动态初始化一个二维数组 int[][] yearArr = new int[oneDimensionalArrayLength][towDimensionalArrayLength]; // 2、键盘录入各个季度的营业额 Scanner sc = new Scanner(System.in); // 定义一个空数组，用于将各个季度的营业额封装成一个数组 // 外循环：遍历二维数组，依次得到每个一维数组 for (int i = 0; i < yearArr.length; i++) { // yearArr[i]: 表示依次得到的季度数组（一维数组） // 内循环：遍历一维数组，依次将各个季度的营业额录入一维数组中 for (int j = 0; j < yearArr[i].length; j++) { System.out.println("请您输入第" + (i + 1) + "季度的第" + (j + 1) + "个营业额："); int turnover = sc.nextInt(); // 将营业额添加进一维数组 yearArr[i][j] = turnover; } } // 季度的营业额录入完毕，返回二维数组 return yearArr; } /** * 查看各个季度的营业额 * * @param yearArr 各个季度的营业额的二维数组 */ public static void queryQuarterTurnover(int[][] yearArr) { // 遍历一维数组，依次得到每个元素 for (int i = 0; i < yearArr.length; i++) { System.out.print("第" + (i + 1) + "季度："); for (int j = 0; j < yearArr[i].length; j++) { // j: 表示一维数组的索引 /* 三元运算符判断： 如果当前 索引位置 是数组的最后一位，则直接输出元素 如果当前 索引位置 不是数组的最后一位，则输出元素加个空格隔开 */ System.out.print(j == yearArr[i].length - 1 ? yearArr[i][j] : yearArr[i][j] + " "); } // 每遍历完一个季度的营业额，就打印换行输出下一个季度的营业额 System.out.println(); } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
请您输入第1季度的第1个营业额： 22 请您输入第1季度的第2个营业额： 66 请您输入第1季度的第3个营业额： 44 请您输入第2季度的第1个营业额： 77 请您输入第2季度的第2个营业额： 33 请您输入第2季度的第3个营业额： 88 请您输入第3季度的第1个营业额： 25 请您输入第3季度的第2个营业额： 45 请您输入第3季度的第3个营业额： 65 请您输入第4季度的第1个营业额： 11 请您输入第4季度的第2个营业额： 66 请您输入第4季度的第3个营业额： 99 查看所有季度的营业额： 第1季度：22 66 44 第2季度：77 33 88 第3季度：25 45 65 第4季度：11 66 99 ------------------------------------- 第1季度的总营业额为：132万元 第2季度的总营业额为：198万元 第3季度的总营业额为：135万元 第4季度的总营业额为：176万元 全年的总营业额为：641万元 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
请您输入第1季度的第1个营业额： 2 请您输入第1季度的第2个营业额： 1 请您输入第1季度的第3个营业额： 2 请您输入第2季度的第1个营业额： 3 请您输入第2季度的第2个营业额： 3 请您输入第2季度的第3个营业额： 3 请您输入第3季度的第1个营业额： 10 请您输入第3季度的第2个营业额： 20 请您输入第3季度的第3个营业额： 30 请您输入第4季度的第1个营业额： 6 请您输入第4季度的第2个营业额： 6 请您输入第4季度的第3个营业额： 6 查看所有季度的营业额： 第1季度：2 1 2 第2季度：3 3 3 第3季度：10 20 30 第4季度：6 6 6 ------------------------------------- 第1季度的总营业额为：5万元 第2季度的总营业额为：9万元 第3季度的总营业额为：60万元 第4季度的总营业额为：18万元 全年的总营业额为：92万元 Process finished with exit code 0- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
-
- 目的：
-
相关阅读:
【leetcode】【2022/8/28】793. 阶乘函数后 K 个零
select....for update会锁表还是锁行
LeetCode每日一题——764. 最大加号标志
实现资源利用率达60% 云原生技术开启节能减排新思路
一文带你深入闭包与作用域链原理（无惧面试）
SpringIOC的bean自动注解（Resource，Autowired）
世界杯网页梦幻联动.html
拉曼光谱仪 便携式手持拉曼光谱分析仪识别仪 1064激发波长 抗荧光干扰 无损快速一键检测TFN F670
使用AfxGetApp()-＞GetMainWnd()而不是AfxGetMainWnd()使得MFC主程序接收辅助线程发送的消息
重读《纳瓦尔宝典》精彩语录及感悟篇（二）
- 原文地址：https://blog.csdn.net/yelitoudu/article/details/127673577
