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; // 返回最终的机票价格 } }请您输入机票原价： 1000 请您输入月份： 11 请您选择舱位： 0.头等舱 1.经济舱 0 您成功购买了机票，共花费 700 元。 Process finished with exit code 0
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 请您输入一个数作为范围的结束： 10 数字1既不是质数，也不是合数 2是质数~ 3是质数~ 5是质数~ 7是质数~ 1~10这个范围内总共有4个质数！ Process finished with exit code 0请您输入一个数作为范围的起始： -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
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; } }验证码：Lqke4 Process finished with exit code 0验证码：LvqT8 Process finished with exit code 0
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, 33, 22, 5, 9] 新数组：[1, 33, 22, 5, 9] Process finished with exit code 0
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位评委给选手打分： -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
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; } }加密前的密码：1983 加密后的密码：8346 Process finished with exit code 0
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; } }加密前的密码：1983 加密后的密码：8346 解密后的密码：1983 Process finished with exit code 0
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; } }10000元的奖金被抽出~ 888元的奖金被抽出~ 2元的奖金被抽出~ 1000元的奖金被抽出~ 588元的奖金被抽出~ Process finished with exit code 0
-
方式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 + "元的奖金被抽出~"); } } }10000元的奖金被抽出~ 488元的奖金被抽出~ 200元的奖金被抽出~ 1元的奖金被抽出~ 300元的奖金被抽出~ 100元的奖金被抽出~ Process finished with exit code 0
-
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; } }================================ 本期双色球号码： 红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
11、二维数组
（1）什么是二维数组？
-
二维数组：
数组中的数组- 就是将很多个一维数组放到一个大的数组当中，方便管理，也叫
二维数组。
-
我们之前学的都是一维数组：
（2）二维数组的应用场景？
- 当我们需要把数据进行分组管理的时候，就需要用到二维数组。
- 举例：
- 某商城每个季度的营业额如下：单位(万元)
- 第一季度：22,66,44
- 第二季度：77,33,88
- 第三季度：25,45,65
- 第四季度：11,66,99
- 要求计算出每个季度的总营业额和全年的总营业额
- 分析：
- 要把每个季度都分别使用一维数组，再用一个大的数组将这些季度都装起来，这就是二维数组的应用场景。
- 某商城每个季度的营业额如下：单位(万元)
（3）二维数组的初始化
a.静态初始化
-
格式：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2}, {元素1,元素2},...};-
范例：
int[][] arr = new int[][]{{11,22}, {33,44}};
-
-
简化格式(常用)：
数据类型[][] 数组名 = {{元素1,元素2}, {元素1,元素2},...};-
范例1(常用)：
int[][] arr = {{11,22}, {33,44}}; -
范例2：
int arr[][] = {{11,22}, {33,44}};
-
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();
}
}
}
[I@119d7047
1
7
------------------------------
1 2 3
4 5 6 7 8
Process finished with exit code 0
b.动态初始化
-
格式：
数据类型[][] 数组名 = new 数据类型[m][n];-
m：表示二维数组的长度（二维数组可以存放多少个一维数组） -
n：表示一维数组的长度（一维数组可以存放多少个元素） -
范例：
int[][] arr = new int[2][3];- 该二维数组可以存放
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();
}
}
}
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
（4）二维数组的内存图
-
特殊情况一：（了解）
- 好处就是，二维数组中的一维数组，我们可以自己定义一维数组的长度，这样比较灵活。
-
特殊情况二：（了解）
总结
1、什么时候使用二维数组呢？
- 当我们需要把数据分组管理的时候，就需要用到二维数组。
2、关于二维数组我们需要掌握什么？
- 掌握二维数组的静态初始化、动态初始化。
3、如何给二维数组中的元素赋值？
-
格式：
数组名[索引] = 值; // 给二维数组中的元素赋值 数组名[索引][索引] = 值; // 给二维数组中的一维数组赋值
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个季度的总营业额为：132万元~ 第2个季度的总营业额为：198万元~ 第3个季度的总营业额为：135万元~ 第4个季度的总营业额为：176万元~ 全年的总营业额为：641万元~ Process finished with exit code 0
-
动态初始化二维数组的方式实现：
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季度的第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季度的第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
-
2069
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
