linux办公网
10-JavaSE基础巩固练习：综合练习、二维数组
创始人
2024-04-03 17:12:23
0次

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.内循环结束，判断flagif (flag) {// 如果还为true，说明当前这个数是质数// (1) 判断i是否为1if (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是否小于等于25if (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=122chs[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=90chs[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;}
}

    验证码：Lqke4Process finished with exit code 0
    验证码：LvqT8Process 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个评委的平均分，请完成上述过程并计算出选手的得分。

  • 分析：

    • 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、计算平均分：(总分 - 最高分 - 最低分) / 4int 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~100if (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位评委给选手打分：
886名评委的打分为：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，则返回-1if (password <= 0) {return -1;}// (1) 计算密码的个数，用作于存储每位密码的数组的长度// 定义计数变量，用于统计密码的个数int count = 0;// 用一个临时变量存储原密码，方便后续使用int tempPassword = password;// 使用while循环计算密码的个数while (password != 0) {// 假如密码：1983，循环不断除以10password = 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.先得到密码的每一位数，都加5for (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
加密后的密码：8346Process 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，则返回nullif (encryptPassword <= 0) {return -1;}// (1) 计算密码的个数，用作于存储每位密码的数组的长度// 定义计数变量，用于统计密码的个数int count = 0;// 用一个临时变量存储原密码，方便后续使用int tempPassword = encryptPassword;// 使用while循环计算密码的个数while (encryptPassword != 0) {// 假如密码：12345，循环不断除以10encryptPassword = 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.先得到密码的每一位数，都减5for (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，则返回-1if (password <= 0) {return -1;}// (1) 计算密码的个数，用作于存储每位密码的数组的长度// 定义计数变量，用于统计密码的个数int count = 0;// 用一个临时变量存储原密码，方便后续使用int tempPassword = password;// 使用while循环计算密码的个数while (password != 0) {// 假如密码：1983，循环不断除以10password = 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.先得到密码的每一位数，都加5for (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
解密后的密码：1983Process 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、传入的数组如果为nullif (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]) {// 存在，返回truereturn true;}}// 循环结束，仍然找不到，说明不存在，返回falsereturn 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]) {// 相等，返回truereturn true;}}// 循环结束，说明该元素与其他元素不相等，返回falsereturn 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}};// 格式1int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5, 6, 7, 8}};// 格式2int[][] 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]);    // 报错：ArrayIndexOutOfBoundsExceptionSystem.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 0Process 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
词库加载错误:未能找到文件“E:\highferrum_mysql\Configuration\Dict_Stopwords.txt”。

上一篇：redis 连接打满的解决

下一篇：文件上传与Phar反序列化的摩擦

相关内容

热门资讯

银河麒麟V10SP1高级服务器... 银河麒麟高级服务器操作系统简介： 银河麒麟高级服务器操作系统V10是针对企业级关键业务...
【NI Multisim 14...   目录 序言 一、工具栏 🍊1.“标准”工具栏 🍊 2.视图工具...
AWSECS：访问外部网络时出... 如果您在AWS ECS中部署了应用程序，并且该应用程序需要访问外部网络，但是无法正常访问，可能是因为...
不能访问光猫的的管理页面 光猫是现代家庭宽带网络的重要组成部分，它可以提供高速稳定的网络连接。但是，有时候我们会遇到不能访问光...
AWSElasticBeans... 在Dockerfile中手动配置nginx反向代理。例如，在Dockerfile中添加以下代码：FR...
Android|无法访问或保存... 这个问题可能是由于权限设置不正确导致的。您需要在应用程序清单文件中添加以下代码来请求适当的权限：此外...
月入8000+的steam搬砖... 大家好，我是阿阳 今天要给大家介绍的是 steam 游戏搬砖项目，目前...
​ToDesk 远程工具安装及... 目录 前言 ToDesk 优势 ToDesk 下载安装 ToDesk 功能展示 文件传输 设备链接 ...
北信源内网安全管理卸载 北信源内网安全管理是一款网络安全管理软件，主要用于保护内网安全。在日常使用过程中，卸载该软件是一种常...
AWS管理控制台菜单和权限 要在AWS管理控制台中创建菜单和权限，您可以使用AWS Identity and Access Ma...