目录
- 买飞机票案例
- 找质数
- 开发验证码
- 数组的复制
- 评委打分
- 数字加密
- 数字解密
- 随机抽奖系统
- 双色球彩票系统
下面就让我们一起来练习一下吧！！！
买飞机票案例
需求：1，机票价格按照淡季旺季，头等舱和经济舱的收费。 输入机票的原价，月份和头等舱或经济舱。 按照以下规则计算机票的价格。
旺季：(5-10月)头等舱9折，经济舱8.5折。
淡季:(11月到4月)头等舱7折，经济舱6.5折
分析：1.键盘录入。2.判断当前输入的是旺季还是淡季。3.选择要购买的舱位。4.计算出对应的折扣。
第一步：键盘录入
System.out.println("请输入机票的原价：");
int money = sc.nextInt();
System.out.println("请输入当前的月份");
int month = sc.nextInt();
System.out.println("请输入您购买的位置:0:头等舱 1:经济舱 ");
int location = sc.nextInt();
第二步：判断当前输入的是旺季还是淡季
// 2.通过键盘输入判断当前月份是旺季还是淡季
if (month >= 5 && month <= 10){
// 旺季
}else if((month >= 1 && month <= 4) || (month >= 11 && month <= 12)){
// 淡季
}else{
System.out.println("当前输入的月份不合规，请重新输入！");
return;
}
第三步：编写一个方法判断选择的位置和计算对应的折扣
// 定义方法计算折扣
public static int disCount(int money,int location,double m0,double m1){
// 3.判断当前位置是头等舱还是经济舱
if (location == 0) {
// 4.根据实际情况计算出对应的价格
// 头等舱
// 要加小括号表示将折扣结果强转成int类型。
money = (int) (money * m0);
} else if (location == 1) {
// 经济舱
money = (int) (money * m1);
} else {
System.out.println("没有这个舱位，请重新输入！");
}
return money;
}
第四步：调用方法求旺季和淡季的折扣
// 旺季 头等舱：9折，经济舱0.85折
// 票价=调用disCount方法里面的计算折扣，传值(票价,位置,头等舱折扣,经济舱折扣)
money = disCount(money,location,0.9,0.85);
// 淡季 头等舱7折，经济舱0.65折
money = disCount(money,location,0.7,0.65);
完整代码：
public static void main(String[] args) {
// 练习一：买飞机票
/*需求：1，机票价格按照淡季旺季，头等舱和经济舱的收费。
输入机票的原价，月份和头等舱或经济舱。
按照以下规则计算机票的价格。
旺季：(5-10月)头等舱9折，经济舱8.5折。
淡季:(11月到4月)头等舱7折，经济舱6.5折*/
// 1.键盘录入对应的信息
Scanner sc = new Scanner(System.in);
System.out.println("请输入机票的原价：");
int money = sc.nextInt();
System.out.println("请输入当前的月份");
int month = sc.nextInt();
System.out.println("请输入您购买的位置:0:头等舱 1:经济舱 ");
int location = sc.nextInt();
// 2.通过键盘输入判断当前月份是旺季还是淡季
if (month >= 5 && month <= 10){
// 票价=调用disCount方法里面的计算折扣，传值(票价,位置,头等舱折扣,经济舱折扣)
money = disCount(money,location,0.9,0.85);
}else if((month >= 1 && month <= 4) || (month >= 11 && month <= 12)){
money = disCount(money,location,0.7,0.65);
}else{
System.out.println("当前输入的月份不合规，请重新输入！");
return;
}
System.out.println(money);
}
// 定义方法计算折扣
public static int disCount(int money,int location,double m0,double m1){
// 3.判断当前位置是头等舱还是经济舱
if (location == 0) {
// 4.根据实际情况计算出对应的价格
// 头等舱
// 要加小括号表示将折扣结果强转成int类型。
money = (int) (money * m0);
} else if (location == 1) {
// 经济舱
money = (int) (money * m1);
} else {
System.out.println("没有这个舱位，请重新输入！");
}
return money;
}
我们来运行看一下效果吧：
找质数
需求：键盘输入一个开始位置和结束位置，求这个范围之间有多少个质数，并输出所有的质数。
第一步：键盘输入开始和结束位置。
System.out.println("请输入一个开始数字：");
int number1 = sc.nextInt();
System.out.println("请输入一个结束数字：");
int number2 = sc.nextInt();
第二步：编写一个方法用来求这个范围的质数
// 外循环：遍历得到这个循环中的每一个数字，i表示每一个数字，开始位置为传过来的初始位置，结束位置为传过来的结束位置
for (int i = number1; i <= number2; i++) {
// 内循环：判断当前数字是否为一个质数
for (int j = 2; j < i; j++) {
if(i % j == 0){
// 不是质数
}
}
}
第三步：判断是否为质数
// 定义一共变量用来统计有多少个质数
int count = 0;
// 假设当前数字是质数
boolean flag = true;
// 如果i的数字能够被2整除就证明不是质数，然后将flag置为false
flag = false;
break;
// 如果flag等于true，那么就将个数+1。
if(flag){
// 打印出全部质数
System.out.print(i + " ");
count++;
}
// 将count个数返回给main函数
return count;
第四步：调用方法求质数
// 定义count用来接受返回的个数，并输出
int count = prime(number1,number2);
System.out.println("一共有" + count + "个质数");
我们来看下完整代码吧：
public static void main(String[] args) {
// 练习二：找质数
// 需求：键盘输入一个开始位置和结束位置，求这个范围之间有多少个质数，并输出所有的质数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个开始数字：");
int number1 = sc.nextInt();
System.out.println("请输入一个结束数字：");
int number2 = sc.nextInt();
// 定义count用来接受返回的个数，并输出
int count = prime(number1,number2);
System.out.println("一共有" + count + "个质数");
}
// 定义一个方法用来求质数
public static int prime(int number1,int number2){
// 定义一共变量用来统计有多少个质数
int count = 0;
System.out.print(number1 + "到" + number2 + "的质数有：");
// 外循环：遍历得到这个循环中的每一个数字，i表示每一个数字
for (int i = number1; i <= number2; i++) {
// 假设当前数字是质数
boolean flag = true;
// 内循环：判断当前数字是否为一个质数
for (int j = 2; j < i; j++) {
if(i % j == 0){
// 如果i的数字能够被2整除就证明不是质数，然后将flag置为false
flag = false;
break;
}
}
// 如果flag等于true，那么就将个数+1。
if(flag){
// 打印出全部质数
System.out.print(i + " ");
count++;
}
}
System.out.println();
// 将count个数返回给main函数
return count;
}
我们来运行看下效果吧：
开发验证码
需求：定义一个方法实现随机生成一个5位数的验证码。
验证码格式：长度为5，前四位是大写字母或者小写字母，最后一位是数字
分析：A-Z,a-z。 技巧：在以后如果我们要在一堆没有什么规律的数据中随机抽取，可以先把这些数据存放到数组当中。在随机抽取一个索引
第一步：用循环将大写字母和小写字母全部存放到数组里面。
// 1.大写字母和小写字母都放在数组当中。
char[] arr1 = new char[52];
for (int i = 0; i < arr1.length; i++) {
// 如果i小于等于25的话添加小写字母
if(i <= 25){
// 添加小写字母
}else{
// 添加大写字母
}
}
第二步：添加小写字母
// 添加小写字母
// 数组下标从0开始，97+0=97，97强转成char类型就变成了小写字母a。
arr1[i] = (char)(97 + i);
第三步：添加大写字母
// 添加大写字母
// 数组下标从0开始，65+0=97，65强转成char类型就变成了大写字母A。
arr1[i] = (char)(65 + i - 26);
第四步：用循环随机生成4个数组的索引
// 2.用for循环随机抽取4次。
Random r = new Random();
for (int i = 0; i < 4; i++) {
// 随机抽取数组中的索引 随机长度为数组的长度
int arr1index = r.nextInt(arr1.length);
}
第五步：定义一个字符串来拼接随机生成的四个数组索引的字母
// 定义一个字符串类型的变量，用来记录最终的结果
String result = "";
// 利用随机索引获取对应的元素值
// 最终的结果 result = result + 随机字母的元素
result += arr1[arr1index];
第六步：随机抽取0-9的一个数字进行拼接
// 3.随机抽取一个0-9的数字
int numindex = r.nextInt(10);
// 再用字符串拼接上一位随机数
result += numindex;
完整代码：
public static void main(String[] args) {
// 练习三：开发验证码
/*需求：定义一个方法实现随机生成一个5位数的验证码。
验证码格式：长度为5，前四位是大写字母或者小写字母，最后一位是数字*/
// 1.大写字母和小写字母都放在数组当中。
char[] arr1 = new char[52];
for (int i = 0; i < arr1.length; i++) {
// 如果i小于等于25的话添加小写字母
if(i <= 25){
// 添加小写字母
// 数组下标从0开始，97+0=97，97强转成char类型就变成了小写字母a。
arr1[i] = (char)(97 + i);
}else{
// 添加大写字母
// 数组下标从0开始，65+0=97，65强转成char类型就变成了大写字母A。
arr1[i] = (char)(65 + i - 26);
}
}
// 定义一个字符串类型的变量，用来记录最终的结果
String result = "";
// 2.用for循环随机抽取4次。
Random r = new Random();
for (int i = 0; i < 4; i++) {
// 随机抽取数组中的索引 随机数为数组的长度
int arr1index = r.nextInt(arr1.length);
// 利用随机索引获取对应的元素值
// 最终的结果 result = result + 随机字母的元素
result += arr1[arr1index];
}
// 3.随机抽取一个0-9的数字
int numindex = r.nextInt(10);
// 再用字符串拼接上一位随机数
result += numindex;
System.out.println("当前验证码为：" + result);
}
我们来运行看一下效果吧：
是不是每次的验证码都不一样呀！
数组元素的复制
需求：把一个数组中的元素复制到另外一个新的数组中去
第一步：定义初始数组的新的数组
// 定义一个原始数组
int[] arr1= {1,2,3,4,5};
// 动态定义一个新的数组，数组的长度=原始数组
int[] newarr1 = new int[arr1.length];
第二步：原始数组复制到新数组里面
// i表示原始数组中的索引，新数组的每一个元素
for (int i = 0; i < arr1.length; i++) {
// arr1[i]原始数组中的索引元素赋值到newarr1[i]新数组的索引元素
newarr1[i] = arr1[i];
// 遍历打印新数组的元素
System.out.print(newarr1[i] + " ");
}
完整代码：
public static void main(String[] args) {
// 练习四：数组元素的复制
// 需求：把一个数组中的元素复制到另外一个新的数组中去
// 定义一个原始数组
int[] arr1= {1,2,3,4,5};
// 动态定义一个新的数组，数组的长度=原始数组
int[] newarr1 = new int[arr1.length];
// 遍历原始数组，得到原始数组中的每一个元素
System.out.print("原始数组：");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + " ");
}
System.out.println();
// i表示原始数组中的索引，新数组的每一个元素
System.out.print("新数组的元素：");
for (int i = 0; i < arr1.length; i++) {
// arr1[i]原始数组中的索引元素赋值到newarr1[i]新数组的索引元素
newarr1[i] = arr1[i];
// 遍历打印新数组的元素
System.out.print(newarr1[i] + " ");
}
}
我们来运行看一下吧：
评委打分
需求：在唱歌比赛中，有6名评委给选手打分，分数的范围是0-100之间的整数。
选手最后得分为：去掉最高分，最低分后四位评委的平均分，计算出选手的得分
第一步：定义一个数组用来存放评委的打分
// 1.定义一个数组，用来存放6名评委的打分(0-100);
int[] scores = new int[6];
第二步：编写一个方法用来输入六位评委的打分情况
// 定义一个方法用来输入存放六位评委的打分
public static int[] getScore() {
Scanner sc = new Scanner(System.in);
// 2.使用键盘输入6位评委的打分(0-100)
for (int i = 0; i < scores.length;) {
System.out.println("请输入第" + (i + 1) + "位评委的打分：");
int score = sc.nextInt();
// 用if判断输入的分数如果不是0-100的话就执行添加进数组里
if(score <= 100 && score >= 0){
scores[i] = score;
// 如果存进去了那就执行i++, 如果没存进去就不执行i++
i++;
// 不满足的话就执行输出有误
}else{
System.out.println("输入有误，请输入0-100的分数！");
}
}
return scores;
}
第三步：编写一个方法求出数组的最大值
// 3.定义一个方法用来求出数组中的最大值。
public static int getMax(int[] scoresArr){
// 定义一个max用来表示数组的第一个索引为最大值
int max = scoresArr[0];
for (int i = 0; i < scoresArr.length; i++) {
if(scoresArr[i] > max){
max = scoresArr[i];
}
}
return max;
}
第四步：编写一个方法求出数组的最小值
// 4.定义一个方法用来求出数组中的最小值。
public static int getmin(int[] scoresArr){
// 定义一个min用来表示数组的第一个索引为最大值
int min = scoresArr[0];
for (int i = 0; i < scoresArr.length; i++) {
if(scoresArr[i] < min){
min = scoresArr[i];
}
}
return min;
}
第五步：编写一个方法用来求数组中6个分数的和
// 5.定义一个方法用来求出数组中的6个分数的总和。
public static int getSum(int[] scoresArr){
int arrsum = 0;
for (int i = 0; i < scoresArr.length; i++) {
arrsum += scoresArr[i];
}
return arrsum;
}
第六步：main函数调用每个方法依次求出最终成绩
// 1.调用getScore方法获取键盘输入的分数并遍历
int[] scoresArr = getScore();
// 2.调用getMax方法求出数组中的最大值。
int max = getMax(scoresArr);
// 3.调用getmin方法求出数组中的最小值。
int min = getmin(scoresArr);
// 4.调用getsum方法求出数组中的6个分数的总和。
int sum = getSum(scoresArr);
// 5.(总和 - 最大值 - 最小值) / 4，这个4不建议写死。可以写成长度-2，因为除去一个最高分和最低分。
int avg = (sum - max - min) /( scoresArr.length-2);
System.out.println("选手的最终得分为：" + avg);
完整代码：
public static void main(String[] args) {
// 练习五：评委打分
// 需求：在唱歌比赛中，有6名评委给选手打分，分数的范围是0-100之间的整数。
// 选手最后得分为：去掉最高分，最低分后四位评委的平均分，计算出选手的得分
// 调用getScore方法获取键盘输入的分数并遍历
int[] scoresArr = getScore();
System.out.print("评委的打分为：");
for (int i = 0; i < scoresArr.length; i++) {
System.out.print(scoresArr[i] + " ");
}
System.out.println();
// 3.调用getMax方法求出数组中的最大值。
int max = getMax(scoresArr);
// 4.调用getmin方法求出数组中的最小值。
int min = getmin(scoresArr);
// 5.调用getsum方法求出数组中的6个分数的总和。
int sum = getSum(scoresArr);
// 6.(总和 - 最大值 - 最小值) / 4，这个4不建议写死。可以写成长度-2，因为除去一个最高分和最低分。
int avg = (sum - max - min) /( scoresArr.length-2);
System.out.println("选手的最终得分为：" + avg);
}
// 定义一个方法用来输入存放六位评委的打分
public static int[] getScore() {
// 1.定义一个数组，用来存放6名评委的打分(0-100);
int[] scores = new int[6];
Scanner sc = new Scanner(System.in);
// 2.使用键盘输入6位评委的打分(0-100)
for (int i = 0; i < scores.length;) {
System.out.println("请输入第" + (i + 1) + "位评委的打分：");
int score = sc.nextInt();
// 用if判断输入的分数如果不是0-100的话就执行添加进数组里
if(score <= 100 && score >= 0){
scores[i] = score;
// 如果存进去了那就执行i++, 如果没存进去就不执行i++
i++;
// 不满足的话就执行输出有误
}else{
System.out.println("输入有误，请输入0-100的分数！");
}
}
return scores; // 返回数组给主函数使用
}
// 3.定义一个方法用来求出数组中的最大值。
public static int getMax(int[] scoresArr){
// 定义一个max用来表示数组的第一个索引为最大值
int max = scoresArr[0];
for (int i = 0; i < scoresArr.length; i++) {
if(scoresArr[i] > max){
max = scoresArr[i];
}
}
return max; // 返回数组中的最大值
}
// 4.定义一个方法用来求出数组中的最小值。
public static int getmin(int[] scoresArr){
// 定义一个min用来表示数组的第一个索引为最大值
int min = scoresArr[0];
for (int i = 0; i < scoresArr.length; i++) {
if(scoresArr[i] < min){
min = scoresArr[i];
}
}
return min; // 返回数组中的最小值
}
// 5.定义一个方法用来求出数组中的6个分数的总和。
public static int getSum(int[] scoresArr){
int arrsum = 0;
for (int i = 0; i < scoresArr.length; i++) {
arrsum += scoresArr[i];
}
return arrsum; // 返回数组中的总和
}
我们来运行看一下吧：
数字加密
需求：某系统的数字密码(大于0)，采取加密方法进行传输。
规则：先得到每位数，然后每一位数都加上5，在对10取余，最后将数字进行反转，得到一串新数输出。（例如：1983，加密后变成8346）
第一步：键盘录入一串数字
// 1.键盘录入一串数字
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的密码数字：");
int digit = sc.nextInt();
由于我们不知道数组的长度，所以需要先求出数组的长度
// 1.1 计算出数组的长度
int number1 = digit;
// 定义一个临时变量size用来存放输入的digit的值
int size = number1;
// 定义一个变量用来进行统计个数，个数就是数组的长度
int count = 0;
// 只要number1不等于0的时候就继续执行
while (digit != 0){
// 每一次循环就去掉右边的一个数字
digit /= 10;
// 去掉一位就次数+1
count++;
}
这个时候就得到了count的个数，也就是数组的长度，接下来我们就来定义一个动态数组。
// 1.2创建动态数组 数组的长度就是刚才求出来的个数
int[] arr1 = new int[count];
创建好了动态数组后，由于没有索引，所以我们需要创建一个临时的索引，创建好了后就添加进数组里面
// 1.3把整数上的每一位都添加到数组当中
// 定义一个临时索引index，最大长度等于数组长度减1
int index = arr1.length-1;
while (size != 0){
// 获取temp里面的每一位数组
int ge = size % 10;
// 再去掉右边的那位数字
size /= 10;
// 把当前获取到的个位添加到数组里面
arr1[index] = ge;
// 每存放一个index长度就减1
index--;
}
我们把数字全部加入到数组里后就需要进行下一步加密了。
第二步：将数字进行加密处理
题目上说先把每一位数的数字全部先加5处理：
// 2.1 把每位数字加5
for (int i = 0; i < arr1.length; i++) {
arr1[i] += 5;
}
把数字加5后在对10取余：
// 2.2 把每位数字对10取余
for (int i = 0; i < arr1.length; i++) {
arr1[i] %= 10;
}
最后将数字进行反转：
// 2.3 将数组里面的数字进行反转
for (int i = 0,j = arr1.length-1; i < j; i++,j--) {
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}
第三步：把数组里面的每一位数字进行拼接，变成加密后的结果
int number2 = 0;
for (int i = 0; i < arr1.length; i++) {
// 这是什么意思呢？我们来了解一下。例如1 2 3 4：
// number一开始为0，0*10＝0，加上索引为0的数字就得到1。
// 第二次循环的时候1*10=10，10+索引为1的数字2就得到12。
// 第三次循环的时候12*10=120，120+索引为2的数字3就得到123。
// 第四次循环的时候123*10=1230，1230+索引为3的数字4就得到1234。以此类推
number2 = number2 * 10 + arr1[i];
}
完整代码：
public static void main(String[] args) {
// 练习六：数字加密
// 需求：某系统的数字密码(大于0)，采取加密方法进行传输。
// 规则：先得到每位数，然后每一位数都加上5，在对10取余，最后将数字进行反转，得到一串新数输出。（例如：1983，加密后变成8346）
// 1.键盘录入一串数字
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的密码数字：");
int digit = sc.nextInt();
// 1.1 计算出数组的长度
int number1 = digit;
// 定义一个临时变量size用来存放输入的digit的值
int size = number1;
// 定义一个变量用来进行统计个数，个数就是数组的长度
int count = 0;
// 只要number1不等于0的时候就继续执行
while (digit != 0){
// 每一次循环就去掉右边的一个数字
digit /= 10;
// 去掉一位就次数+1
count++;
}
// 1.2创建动态数组 数组的长度就是刚才求出来的个数
int[] arr1 = new int[count];
// 1.3把整数上的每一位都添加到数组当中
// 定义一个临时索引index，最大长度等于数组长度减1
int index = arr1.length-1;
while (size != 0){
// 获取temp里面的每一位数组
int ge = size % 10;
// 再去掉右边的那位数字
size /= 10;
// 把当前获取到的个位添加到数组里面
arr1[index] = ge;
// 每存放一个index长度就减1
index--;
}
// 2.把数字进行加密
// 2.1 把每位数字加5
for (int i = 0; i < arr1.length; i++) {
arr1[i] += 5;
}
// 2.2 把每位数字对10取余
for (int i = 0; i < arr1.length; i++) {
arr1[i] %= 10;
}
// 2.3 将数组里面的数字进行反转
for (int i = 0,j = arr1.length-1; i < j; i++,j--) {
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}
// 3.把数组里面的每一位数字进行拼接，变成加密后的结果
int number2 = 0;
for (int i = 0; i < arr1.length; i++) {
// 这是什么意思呢？我们来了解一下。例如1 2 3 4：
// number一开始为0，0*10＝0，加上索引为0的数字就得到1。
// 第二次循环的时候1*10=10，10+索引为1的数字2就得到12。
// 第三次循环的时候12*10=120，120+索引为2的数字3就得到123。
// 第四次循环的时候123*10=1230，1230+索引为3的数字4就得到1234。以此类推
number2 = number2 * 10 + arr1[i];
}
// 最后将加密后的数字输出
System.out.println("加密后的数字是：" + number2);
}
我们来运行看一下吧：
数字解密
需求：某系统的数字密码(大于0)，采取加密方法进行传输。
规则：先得到每位数，然后每一位数都加上5，在对10取余，最后将数字进行反转，得到一串新数输出。
按照以上规则进行解密：（例如：8346，加密后变成1983）
第一步：定义数组
// 1.定义数组记录解密之后的结果
int[] arr1 = {8,3,4,6};
第二步：将数组进行反转
// 2.将数组的元素反转
for (int i = 0,j = arr1.length -1; i < j; i++,j--) {
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}
第三步：解密
3.1 由于加密是通过对10取余的方式进行获取的，所以在解密的时候就需要判断0-4之间就+10，5-9的数字不变
for (int i = 0; i < arr1.length; i++) {
if(arr1[i] >= 0 && arr1[i] <= 4){
arr1[i] += 10;
}
}
3.2 将数组的元素-5
for (int i = 0; i < arr1.length; i++) {
arr1[i] -= 5;
}
第四步：拼接数字
// 5.获取数组的全部元素对每一位进行拼接成最终的结果
int number = 0;
for (int i = 0; i < arr1.length; i++) {
// 这是什么意思呢？我们来了解一下。例如1 2 3 4：
// number一开始为0，0*10＝0，加上索引为0的数字就得到1。
// 第二次循环的时候1*10=10，10+索引为1的数字2就得到12。
// 第三次循环的时候12*10=120，120+索引为2的数字3就得到123。
// 第四次循环的时候123*10=1230，1230+索引为3的数字4就得到1234。以此类推
number = number * 10 + arr1[i];
}
完整代码：
public static void main(String[] args) {
// 练习七：数字解密
// 需求：某系统的数字密码(大于0)，采取加密方法进行传输。
// 规则：先得到每位数，然后每一位数都加上5，在对10取余，最后将数字进行反转，得到一串新数输出。
// 按照以上规则进行解密：比如1983加密后变成8346，解密后变回1983
// 1.定义数组记录解密之后的结果
int[] arr1 = {8,3,4,6};
// 2.将数组的元素反转
for (int i = 0,j = arr1.length -1; i < j; i++,j--) {
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}
// 3.由于加密是通过对10取余的方式进行获取的
// 所以在解密的时候就需要判断0-4之间就+10，5-9的数字不变
for (int i = 0; i < arr1.length; i++) {
if(arr1[i] >= 0 && arr1[i] <= 4){
arr1[i] += 10;
}
}
// 4.将数组的元素-5
for (int i = 0; i < arr1.length; i++) {
arr1[i] -= 5;
}
// 5.获取数组的全部元素对每一位进行拼接成最终的结果
int number = 0;
for (int i = 0; i < arr1.length; i++) {
// 这是什么意思呢？我们来了解一下。例如1 2 3 4：
// number一开始为0，0*10＝0，加上索引为0的数字就得到1。
// 第二次循环的时候1*10=10，10+索引为1的数字2就得到12。
// 第三次循环的时候12*10=120，120+索引为2的数字3就得到123。
// 第四次循环的时候123*10=1230，1230+索引为3的数字4就得到1234。以此类推
number = number * 10 + arr1[i];
}
// 最后将加密后的数字输出
System.out.println("解密后的数字是：" + number);
}
我们来运行看一下吧：
随机抽奖系统
需求：一个大v直播抽奖，奖品是现金红包，分别有(188,588,888,1088,1888)五个奖金。请使用代码模拟抽奖。
打印出每一个奖项，奖项的出现顺序要随机且不重复
第一步：定义奖池数组
// 1.定义奖池数组
int[] arr1 = {188,588,888,1088,1888};
第二步：获取数组的随机索引
// 获取到数组的随机索引
int randomindex = r.nextInt(arr1.length);
第三步：拿着当前索引和随机到的索引进行交换
// 拿着i跟随机索引randomindex上的值进行交换
int temp = arr1[i];
arr1[i] = arr1[randomindex];
arr1[randomindex] = temp;
完整代码：
public static void main(String[] args) {
// 练习八：抢红包
// 需求：一个大v直播抽奖，奖品是现金红包，分别有(188,588,888,1088,1888)五个奖金。请使用代码模拟抽奖。
// 打印出每一个奖项，奖项的出现顺序要随机且不重复
// 1.定义奖池数组
int[] arr1 = {188,588,888,1088,1888};
Random r = new Random();
for (int i = 0; i < arr1.length; i++) {
// 获取到数组的随机索引
int randomindex = r.nextInt(arr1.length);
// 拿着i跟随机索引randomindex上的值进行交换
int temp = arr1[i];
arr1[i] = arr1[randomindex];
arr1[randomindex] = temp;
}
// 遍历奖池，从索引0开始获取每一个随机的奖项
for (int i = 0; i < arr1.length; i++) {
System.out.println("第" + (i + 1) + "次奖品为：" + arr1[i] + " ");
}
}
我们来运行看一下吧：
双色球彩票系统
需求：投注号码由6个红色球号码和一个蓝色球号码组成，不能重复。
红色球号码从1-33中选择，蓝色球号码从1-16中选择
第一步：编写一个方法来生成中奖号码
// 1.2 创建数组用于存放中奖号码
// 6个红球，1个篮球。数组长度：7
int[] arr1 = new int[7];
定义好了数组后随机生成随机数并存放到数组中
红球：不能重复，例如1，2，3，4，5，6
篮球：可以和红球重复
随机生成红球：
// 生成红球号码并添加到数组当中
for (int i = 0; i < 6;) {
// 生成随机索引的红球号码
int redNumber = r.nextInt(33) + 1;
// 调用contains方法判断是否重复，传数组和随机索引
boolean flag = contains(arr1,redNumber);
// 如果当前号码不存在，就添加进数组里面
if(!flag){
arr1[i] = redNumber;
i++;
}
}
随机生成蓝球：
// 生成蓝球号码并添加到数组当中
int blueNumber = r.nextInt(16) + 1;
// 由于前面的是红球，所以这边可以把数组最大索引赋值给篮球的索引
arr1[arr1.length -1] = blueNumber;
这个时候我们就已经把生成的红球和篮球的随机数都存放进了数组了，接下来我们进行判断。
第二步：编写方法判断号码是否已经存在数组里了。
// 1.3 定义一个方法判断号码在数组中是否存在了
public static boolean contains(int[] arr1,int number){
for (int i = 0; i < arr1.length; i++) {
if(arr1[i] == number){
return true;
}
}
return false;
}
第三步：定义一个方法用来存放用户输入的号码 3.1 创建一个数组存放用户输入的号码
// 1.创建数组用于添加用户输入的号码
int[] arr1 = new int[7];
// 2.利用键盘输入让用户输入
Scanner sc = new Scanner(System.in);
3.2 让用户输入红球号码
// 3.让用户输入红球号码
for (int i = 0; i < arr1.length -1;) {
System.out.println("请输入第" + (i + 1) + "个红球的号码");
int redNumber = sc.nextInt();
// 判断redNumber在1-33中，不重复
if(redNumber >= 1 && redNumber <= 33){
// 调用contains方法判断是否重复，传数组和随机索引
boolean flag = contains(arr1,redNumber);
if(!flag){
// 不存在就添加进数组当中
arr1[i] = redNumber;
i++;
}else{
// 存在就提示用户已经存在了
System.out.println("当前红球号码已经存在，请重新输入");
}
}else{
System.out.println("当前红球号码超出范围，请重新输入！");
}
}
3.3 让用户输入篮球号码
// 4.让用户输入蓝球号码
System.out.println("请输入蓝球号码：");
while (true) {
int blueNumber = sc.nextInt();
if(blueNumber >= 1 && blueNumber <= 16){
arr1[arr1.length -1] = blueNumber;
break;
}else{
System.out.println("当前蓝球号码超出范围，请重新输入！");
}
}
到这里我们就把生成和用户输入的号码全部存进数组里面啦。
第三步：主函数调用方法
// 1.调用ticketNumber方法随机生成中奖号码
int[] arr1 = ticketNumber();
调用userNumber方法让用户输入
// 2.用户输入彩票号码（红球 + 篮球）
int[] userInput = userNumber();
定义两个变量用来统计用户中红球和蓝球的个数
// 3.1 定义两个变量用来统计红球和蓝球的中奖个数
int redCount = 0,blueCount = 0;
首先来判断红球中奖个数：
// 3.2 判断红球
for (int i = 0; i < userInput.length -1; i++) {
int redNumber = userInput[i];
for (int j = 0; j < arr1.length -1; j++) {
if(redNumber == arr1[j]){
redCount++;
// 如果找到了，那么后面的数字就没有必要需要继续比较了。
// 跳出内循环，继续判断下一个红球号码是否中奖
break;
}
}
}
接着来判断蓝球：
// 3.3 判断蓝球
int blueNumber = userInput[userInput.length -1];
if(blueNumber == arr1[arr1.length -1]){
blueCount++;
}
这个时候我们就已经获取到了用户中奖的红球和蓝球个数，接下来就来判断是否中奖。
// 3.4 根据红球和蓝球的个数判断中奖情况
if(redCount == 6 && blueCount == 1){
System.out.println("恭喜你，中一等奖！");
}else if(redCount == 6 && blueCount == 0){
System.out.println("恭喜你，中二等奖！");
}else if(redCount == 5 && blueCount == 1){
System.out.println("恭喜你，中三等奖！");
}else if((redCount == 5 && blueCount == 0) || (redCount == 4 && blueCount == 1)){
System.out.println("恭喜你，中四等奖！");
}else if((redCount == 4 && blueCount == 0) || (redCount == 3 && blueCount == 1)){
System.out.println("恭喜你，中五等奖！");
}else if((redCount == 2 && blueCount == 1) || (redCount == 1 && blueCount == 1)|| (redCount == 0 && blueCount == 1)){
System.out.println("恭喜你，中六等奖！");
}else{
System.out.println("谢谢参与！");
}
完整代码：
public static void main(String[] args) {
// 练习九：双色球彩票系统
// 需求：投注号码由6个红色球号码和一个蓝色球号码组成，不嫩重复，红色球号码从1-33中选择，蓝色球号码从1-16中选择
// 1.调用ticketNumber方法随机生成中奖号码
int[] arr1 = ticketNumber();
System.out.println("================================");
System.out.print("开奖号码：");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + " ");
}
System.out.println();
System.out.println("================================");
// 2.用户输入彩票号码（红球 + 篮球）
int[] userInput = userNumber();
// 3.判断用户的中奖情况
// 3.1 定义两个变量用来统计红球和蓝球的中奖个数
int redCount = 0,blueCount = 0;
// 3.2 判断红球
for (int i = 0; i < userInput.length -1; i++) {
int redNumber = userInput[i];
for (int j = 0; j < arr1.length -1; j++) {
if(redNumber == arr1[j]){
redCount++;
// 如果找到了，那么后面的数字就没有必要需要继续比较了。
// 跳出内循环，继续判断下一个红球号码是否中奖
break;
}
}
}
// 3.3 判断蓝球
int blueNumber = userInput[userInput.length -1];
if(blueNumber == arr1[arr1.length -1]){
blueCount++;
}
// 3.4 根据红球和蓝球的个数判断中奖情况
if(redCount == 6 && blueCount == 1){
System.out.println("恭喜你，中一等奖！");
}else if(redCount == 6 && blueCount == 0){
System.out.println("恭喜你，中二等奖！");
}else if(redCount == 5 && blueCount == 1){
System.out.println("恭喜你，中三等奖！");
}else if((redCount == 5 && blueCount == 0) || (redCount == 4 && blueCount == 1)){
System.out.println("恭喜你，中四等奖！");
}else if((redCount == 4 && blueCount == 0) || (redCount == 3 && blueCount == 1)){
System.out.println("恭喜你，中五等奖！");
}else if((redCount == 2 && blueCount == 1) || (redCount == 1 && blueCount == 1)|| (redCount == 0 && blueCount == 1)){
System.out.println("恭喜你，中六等奖！");
}else{
System.out.println("谢谢参与！");
}
System.out.println("中红球个数" + redCount);
System.out.println("中蓝球个数" +blueCount);
}
// 1.1 定义一个方法用于生成中奖号码
public static int[] ticketNumber(){
// 1.2 创建数组用于存放中奖号码
// 6个红球，1个篮球。数组长度：7
int[] arr1 = new int[7];
// 1.2 随机生成号码并添加到数组当中
// 红球：不能重复，例如1，2，3，4，5
// 篮球：可以和红球重复
// 生成红球号码并添加到数组当中
Random r = new Random();
for (int i = 0; i < 6;) {
// 生成随机索引的红球号码
int redNumber = r.nextInt(33) + 1;
// 调用contains方法判断是否重复，传数组和随机索引
boolean flag = contains(arr1,redNumber);
// 如果当前号码不存在，就添加进数组里面
if(!flag){
arr1[i] = redNumber;
i++;
}
}
// 生成蓝球号码并添加到数组当中
int blueNumber = r.nextInt(16) + 1;
// 由于前面的是红球，所以这边可以把数组最大索引赋值给篮球的索引
arr1[arr1.length -1] = blueNumber;
// 全部生成完毕返回中奖号码的数组
return arr1;
}
// 1.3 定义一个方法判断号码在数组中是否存在了
public static boolean contains(int[] arr1,int number){
for (int i = 0; i < arr1.length; i++) {
if(arr1[i] == number){
return true;
}
}
return false;
}
// 2.1 定义一个方法用于存放用户输入的号码
public static int[] userNumber(){
// 1.创建数组用于添加用户输入的号码
int[] arr1 = new int[7];
// 2.利用键盘输入让用户输入
Scanner sc = new Scanner(System.in);
// 3.让用户输入红球号码
for (int i = 0; i < arr1.length -1;) {
System.out.println("请输入第" + (i + 1) + "个红球的号码");
int redNumber = sc.nextInt();
// 判断redNumber在1-33中，不重复
if(redNumber >= 1 && redNumber <= 33){
// 调用contains方法判断是否重复，传数组和随机索引
boolean flag = contains(arr1,redNumber);
if(!flag){
// 不存在就添加进数组当中
arr1[i] = redNumber;
i++;
}else{
// 存在就提示用户已经存在了
System.out.println("当前红球号码已经存在，请重新输入");
}
}else{
System.out.println("当前红球号码超出范围，请重新输入！");
}
}
// 4.让用户输入蓝球号码
System.out.println("请输入蓝球号码：");
while (true) {
int blueNumber = sc.nextInt();
if(blueNumber >= 1 && blueNumber <= 16){
arr1[arr1.length -1] = blueNumber;
break;
}else{
System.out.println("当前蓝球号码超出范围，请重新输入！");
}
}
return arr1;
}
我们来运行看一下吧：
好啦，以上就是Java的综合案例一，对于刚入手的你是不是觉得有点难呢？没事，经过你的多次练习，相信你能做到轻而易举的。有什么不懂的可以在评论区评论哟！
==最后非常感谢您的阅读，也希望能得到您的反馈 ==
