本篇文章是Java方法的专题练习,从第五题开始难度增大,涉及大厂真题,前四道题目是基础练习,友友们可有目的性的选择学习😘💕
文章目录
- 前言
- 一、数组的遍历
- 1.注意点:输出语句的用法
- 2.题目正解
- 二、数组最大值
- 三、判断是否存在
- 四、复制数组
- 五、案例一:卖飞机票
- 六、案例二:找质数
- 七、案例三:开发验证码
- 八、案例四:数字元素的复制
- 九、案例五:评委打分
- 十、案例六:数字加密
- 十一、案例七:数字解密
- 十二、案例八:抢红包
- 十三、案例九：双色球彩票系统
- 第一步随机生成中奖号码:
- 第二步用户输入彩票号码
- 第三步判断用户的中奖情况
- 总结
前言
一、数组的遍历
1.注意点:输出语句的用法
System.out.println("abc"); //先打印abc,再进行换行
System.out.print("abc"); //只打印abc,不换行
System.out.println(); //不打印任何数据,只做换行处理
2.题目正解
import java.sql.SQLOutput;
public class MethodTest1 {
public static void main(String[] args) {
int[] arr={11,22,33,44,55};
printArr(arr);
//输出语句的用法
/* System.out.println("abc"); //先打印abc,再进行换行
System.out.print("abc"); //只打印abc,不换行
System.out.println(); //不打印任何数据,只做换行处理
*/
}
public static void printArr(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
System.out.print(arr[i]);
}else{
System.out.print(arr[i]+",");
}
}
System.out.print("]");
}
}
二、数组最大值
public class MethodTest2 {
public static void main(String[] args) {
int[] arr={1,0,9,5,4,2,6};
System.out.println("数组的最大值是:"+getMax(arr));
}
public static int getMax(int[] arr){
int max=arr[0]; //max必须是数组中的数值
for (int i = 1; i+1< arr.length; i++) {
if(arr[i]>max){
max=arr[i];
}
}
return max;
}
}
三、判断是否存在
import java.util.Scanner;
public class MethodTest3 {
public static void main(String[] args) {
int[] arr={1,2,3,4,5};
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数:");
int num=sc.nextInt();
System.out.println("整数存在吗?"+getExisit(num,arr));
}
public static boolean getExisit(int num,int[] arr){
for (int i = 0; i < arr.length; i++) {
if(num==arr[i]){
return true;
}
}
return false;
}
}
四、复制数组
比如说想要下标3~7之间的数据
分析结果如下:
public class MethodTest4 {
public static void main(String[] args) {
//1.定义原始数组
int[] arr={1,2,3,4,5,6,7,8,9};
//2.调用方法拷贝数据
int[] copyArr=copyOfRange(arr,3,7);
//3.遍历copyArr
for (int i = 0; i < copyArr.length; i++) {
System.out.print(copyArr[i]+" ");
}
}
public static int[] copyOfRange(int[] arr,int from,int to){
//1.定义数组
//静态:知道所有元素
//动态:不知道所有元素,但是知道要存几个元素,这个可以用to-from算出来
int[] newArr=new int[to-from];
//2.把原始数组arr中的from到to上对应的元素,直接拷贝到newArr中
//格式:数组名[索引]=数据值;
//伪造索引的思想:没有一个变量能表示当前索引的范围用
int index=0;
for(int i=from;i<to;i++){
newArr[index]=arr[i];
index++;
}
//3.把新数组返回,注意要将方法的返回类型改为int[]
return newArr;
}
}
五、案例一:卖飞机票
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//分析:
//1.键盘录入机票,月份,头等舱或者经济舱
Scanner sc=new Scanner(System.in);
System.out.println("请输入机票的原价:");
int price=sc.nextInt();
System.out.println("请输入购买机票的月份:");
int month=sc.nextInt();
System.out.println("请输入购买机票的舱位(0代表头等舱,1代表经济舱):");
int seat=sc.nextInt();
//2.判断是淡季还是旺季
if(month>=5&&month<=10){ //3.继续判断当前机票是经济舱还是头等舱
//旺季
if(seat==0){
//头等舱
price=(int)(price*0.9); //机票一般是整数,这里将最终机票的价格强转成整数
}else if(seat==1){
//经济舱
price=(int)(price*0.85); //注意强制转换类型的时候要在后面式子的整体加小括号
}else{
System.out.println("没有这个舱位");
}
}else if(month>=1&&month<=4||month>=11&&month<=12){
//淡季
if(seat==0){
//头等舱
price=(int)(price*0.7); //机票一般是整数,这里将最终机票的价格强转成整数
}else if(seat==1){
//经济舱
price=(int)(price*0.65); //注意强制转换类型的时候要在后面式子的整体加小括号
}else{
System.out.println("没有这个舱位");
}
}else{
//表示键盘录入的月份是一个非法数据
System.out.println("键盘输入的月份不合法");
}
//4.根据实际情况计算出相应的价格
System.out.println(price);
}
}
为了提高代码的复用性,可以将下面圈出来的写成方法.
优化后的代码:
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//分析:
//1.键盘录入机票,月份,头等舱或者经济舱
Scanner sc=new Scanner(System.in);
System.out.println("请输入机票的原价:");
int price=sc.nextInt();
System.out.println("请输入购买机票的月份:");
int month=sc.nextInt();
System.out.println("请输入购买机票的舱位(0代表头等舱,1代表经济舱):");
int seat=sc.nextInt();
//2.判断是淡季还是旺季
if(month>=5&&month<=10){ //3.继续判断当前机票是经济舱还是头等舱
//旺季
price=getPrice(price,seat,0.9,0.85);
}else if(month>=1&&month<=4||month>=11&&month<=12){
//淡季
price=getPrice(price,seat,0.7,0.65);
}else{
//表示键盘录入的月份是一个非法数据
System.out.println("键盘输入的月份不合法");
}
//4.根据实际情况计算出相应的价格
System.out.println(price);
}
//1.我要干嘛?根据舱位和折扣计算最终的票价
//2.我干这件事,需要什么?票的原价,舱位,头等舱的折扣,经济舱的折扣
//3.方法的使用是否需要这个结果?需要
public static int getPrice(int price,int seat,double v0,double v1){
if(seat==0){
//头等舱
price=(int)(price*0.9); //机票一般是整数,这里将最终机票的价格强转成整数
}else if(seat==1){
//经济舱
price=(int)(price*0.85); //注意强制转换类型的时候要在后面式子的整体加小括号
}else{
System.out.println("没有这个舱位");
}
return price;
}
}
idea中快捷键的小扩展:
ctrl+alt+M 选中代码,自动抽取方法
ctrl+p 使用方法时在小括号中点击,可以看到该方法的形参内容
六、案例二:找质数
public class Test5 {
public static void main(String[] args) {
//判断101-200之间有多少个质数,并输出所有质数
//怎么判断质数?
//方法1.循环判断2~x-1之间有没有数字能被它整除
//方法2.循环判断2~这个数的平方根
//方法一:
//定义变量:赋值100
//判断i是否为质数
for (int i = 101; i <= 200; i++) {
//i依次表示循环中的每一个数字
boolean flag=true;
for(int j=2;j<i;j++){
//j表示2-99之间的每一个数字
if(i%j==0){
flag=false;
break;
}
}
if(flag){
System.out.println("当前数字"+i+"是质数");
}
}
}
}
注意上面代码中break跳出的是单层循环,这里跳出的是内循环,跳出之后执行下面的语句.
七、案例三:开发验证码
分析:
题目核心:随机
在以后如果要在一堆没有规律的数据中抽取,可以先把数据放到数组中,再随机抽取一个索引
1.大写字母和小写字母都放到数组中
2.随机抽取四次
3.随机抽取一个数字0~9
import java.util.Random;
public class Test6 {
public static void main(String[] args) {
/*
需求:定义方法实现随机产生一个五位的验证码
验证码格式:
长度为5
前四位是大写字母或者小写字母
最后一位是数字
*/
/*
1.大写字母和小写字母都放到数组中
2.随机抽取四次
3.随机抽取一个数字0~9
*/
char[] chs=new char[52];
for (int i = 0; i < chs.length; i++) {
//chs[i]='a';
//ASCII码表
if(i<=25){
//添加小写字母
//a----97
chs[i]=(char)(97+i);
}else{
//添加大写字母
//A----65
//这里要减去26,因为如果i是26,当65+26时就不是想要的大写字母A
chs[i]=(char)(65+i-26);
}
}
//遍历
/* for (int i = 0; i < chs.length; i++) {
System.out.print(chs[i]+" ");
}
*/
//定义一个字符串类型的变量,用来记录最终的结果
String result=""; //长度为0,什么都没有的字符串
//2.随机抽取四次
//随机抽取数组中的索引
Random r=new Random();
//循环四次
for (int i = 0; i < 4; i++) {
//想要的索引是0-51
int randomIndex=r.nextInt(chs.length);
//利用随机索引,获取对应的元素
//System.out.println(chs[randomIndex]);
//将四个字符拼接起来
result=result+chs[randomIndex];
}
//3.随机抽取一个数字0-9
int number= r.nextInt(10);
//将result和number拼接,将结果赋值给reuslt
result=result+number;
System.out.println(result);
}
}
八、案例四:数字元素的复制
分析:
1.定义一个老数组并存储一些元素
2.定义一个新数组的长度和老数组一样
3.遍历老数组,得到老数组里面的每一个元素,依次存入到新数组中
public class Test7 {
public static void main(String[] args) {
/*
需求:
把一个数组里面的元素复制到另一个数组里
*/
// 分析:
// 1.定义一个老数组并存储一些元素
int[] arr={1,2,3,4,5};
// 2.定义一个新数组的长度和老数组一样
int[] newArr=new int[arr.length];
// 3.遍历老数组,得到老数组里面的每一个元素,依次存入到新数组中
for (int i = 0; i < arr.length; i++) {
newArr[i]=arr[i];
}
//4.数组里面已经存满元素了
for (int i = 0; i < newArr.length; i++) {
System.out.println(newArr[i]);
}
}
}
九、案例五:评委打分
分析:
1.定义一个数组,用来存储6名评委的打分(0-100)键盘录入
2.求出数组中的最大值
3.求出数组中的最小值
4.求出数组的总和
5.(总和-最大值-最小值)/4
方法:
1.我要干嘛?
定义一个数组,用来存储6名评委的打分(0-100)
2.我需要干什么?
什么也不需要
3.干完了这件事,需不需要返回?
需要返回
注意点:
1.键盘录入评委的打分时,判断打出的分数是不是在0-100之间,如果在这个范围内存这个数据,不在这个范围内,不存这个数据且不做其他的改变.所以要注意存放数据的数组下标++的放置位置.
2.第五步/4,最好不要写死,当数组长度变化时该代码还需要修改,所以最好写成:数组.length-2
小技巧:
变量的批量修改:
选中变量名,点击shift+f6,在修改变量名,就可对变量名批量修改
import java.util.Scanner;
public class Test8 {
public static void main(String[] args) {
//1.定义一个数组,用来存储6名评委的打分
int[] scoreArr=getScores();
for (int i = 0; i < scoreArr.length; i++) {
System.out.println(scoreArr[i]);
}
//2.求出数组的最大值
int max=getMax(scoreArr);
//3.求数组的最小值
int min=getMin(scoreArr);
//4.求出数组中6个分数的总和
int sum=getSum(scoreArr);
//5.(总和-最大值-最小值)/(长度-2)
int avg=(sum-max-min)/(scoreArr.length-2);
//打印结果
System.out.println("选手的最终得分是:"+avg);
}
//求出数组中6个分数的总和
public static int getSum(int[] scoreArr){
int sum=0;
for (int i = 0; i < scoreArr.length; i++) {
sum=sum+scoreArr[i];
}
return sum;
}
//求数组的最大值
public static int getMax(int[] scoreArr){
int max=scoreArr[0];
for (int i = 1; i < scoreArr.length; i++) {
if(scoreArr[i]>max){
max=scoreArr[i];
}
}
return max;
}
//求数组的最小值
//变量的批量修改
//选中变量名,点击shift+f6,在修改变量名,就可对变量名批量修改
public static int getMin(int[] scoreArr){
int min=scoreArr[0];
for (int i = 1; i < scoreArr.length; i++) {
if(scoreArr[i]<min){ //注意在将求最大值的代码复制过来之后,要将这里改为<
min=scoreArr[i];
}
}
return min;
}
public static int[] getScores(){
//定义数组
int[] scores=new int[6];
//使用键盘录入的形式,输入分数(0-100)
Scanner sc=new Scanner(System.in);
for (int i = 0; i < scores.length; ) { //这里的条件控制为空,表示如果录入错误,下标不进行修改,继续在当前下标录入,当录入成功后再进行i++,所以写在下面
System.out.println("请输入评委的打分:");
int score=sc.nextInt();
if(score>=0&&score<=100){
scores[i]=score;
i++; //只有录入了一个合法的数据,才录入,录入成功后才往下录入下一个成绩
}else{
System.out.println("成绩超出了范围,继续录入,当前的i为:"+i);
}
}
return scores;
}
}
十、案例六:数字加密
针对这种数字的批量计算,我们的思路是把这些数字放到数组中,然后再对里面的元素进行运算
分析:
1.把整数中的每一位放到数组中
2.加密
3.把数组里面的每一个数字进行拼接,变成加密之后的结果
public class Test9 {
public static void main(String[] args) {
/*
需求:
某系统的数字密码(大于0).比如1983,采用加密方式进行传输
规则如下:
每位数+5
再对10求余
最后将所有数字反转
得到一串新数字
*/
// 分析:
// 1.把整数中的每一位放到数组中
int[] arr={1,9,8,3};
// 2.加密(为了让思路更加清晰,我们让每个循环干一件事情)
//(1)每一位数字+5
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]+5;
}
//(2)再对10求余
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]%10;
}
//(3)将所有数字反转
//定义两个索引变量,左右两边相互交换,直到左边的索引比右边的索引大或者相等时停止
for (int i = 0,j=arr.length-1; i < j; i++,j--) {
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
// 3.把数组里面的每一个数字进行拼接,变成加密之后的结果
int number=0;
for (int i = 0; i < arr.length; i++) {
//arr[i]
number=number*10+arr[i];
}
System.out.println(number);
}
}
接下来针对这道题中的难点进行讲解:
如何将一个整数中的数字每一位放到数组里面?
public class Test10 {
public static void main(String[] args) {
/*
需求:
把整数每一位都添加到数组中
大于0的整数
反向推导
*/
//需要有一个数组
//动态初始化(不知道数组元素的时候,但是知道有几个) 静态初始化(知道数组元素)
//使用动态初始化 int[] arr=new int[数组的长度];
//数组的长度不知道,所以要计算出
//1.计算出数组的长度
int number=12345;
int temp=number;
//定义一个变量进行统计
int count=0;
while (number!=0){ //当number不等于0时就要去掉
//每一次循环去掉右边的一个数字
number=number/10;
//去掉一次计数器就自增一次
count++;
//循环结束之后,count就是数字的个数
}
//2.定义数组
//动态初始化
int[] arr=new int[count];
//3.把整数每一位都添加到数组中
//不能从number中获取数字,因为上面的循环结束后,number的值为0
//所以还要定义一个变量,临时记录number的值
int index=arr.length-1; //注意要把5放到最大索引,所以这里index不是0,而是最大索引
while(temp!=0){
//获取temp里面的每一位都添加到数组中
int ge=temp%10;
//再去掉右边的那位数字
temp=temp/10;
//再把当前获取的个位数添加到数组当中
//arr[索引]=ge; 所以这里要定义变量索引
arr[index]=ge;
index--;
}
//验证结果是不是:1 2 3 4 5
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
十一、案例七:数字解密
思路过程:
反过来推,但是中间%10那一步反过来是什么呢?
第二排: 6 14 13 8
它们是通过第一排+5得来的数字
第二排的最大值只能到14,因为第一排最大的只能到9,9+5=14;最小值是5,虽然第一排1 9 8 3中没有0,但是假设有0,那么第二排最小的就是5.
所以第二排的数字范围是5~14之间
在对10取余时的结果:
所以在解密的时候,5 ~ 9不需要动, 0~4需要+10
才能恢复原来的数字
分析:
1.定义数组记录解密之后的结果
2.反转
3.由于加密是对10取余的方式进行获取的,所以在解密的时候就需要判断,0~ 4之间+10, 5~9数字不变
4.每一位-5
5.获取数组里面的每一位数字并拼接成最终的结果,注意number=number*10+arr[i];
public class Test11 {
public static void main(String[] args) {
//1.定义数组记录解密之后的结果
int[] arr={8,3,4,6};
//2.先反转
for (int i = 0,j=arr.length-1; i < j; i++,j--) {
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
//3.由于加密是对10取余的方式进行获取的,
//所以在解密的时候就需要判断,0~4之间+10,5~9数字不变
for (int i = 0; i < arr.length; i++) {
if(arr[i]>=0&&arr[i]<=4){
arr[i]=arr[i]+10;
}
}
//4.每一位-5
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]-5;
}
//5.获取数组里面的每一位数字并拼接成最终的结果
int number=0;
for (int i = 0; i < arr.length; i++) {
number=number*10+arr[i];
}
System.out.println(number);
}
}
十二、案例八:抢红包
思路:
随机数会想到Random,但是Random可能下一次随机的数字与上次相同.
那怎么办呢?
定义一个新的数组,里面什么也没有,将随机到的数据添加到数组中,下一次随机得到的数据和这个数组中的数据进行比较,存在的话那么就是无效的奖项,需要重抽一次.
分析:
1.定义数组表示奖池
2.定义新数组用于存储抽奖的结果
定义方法判断prize在数组中是否存在
存在:true
不存在:false
3.抽奖
(1)因为有5个奖项,所以要循环五次
(2)获取随机索引
(3)获取奖项
(4)判断当前的奖项是否存在,如果存在则重新抽取,如果不存在,表示有效奖项
(5)把当前抽到的奖项添加到NewArr当中
(6)只有当抽到的是有效奖项时,索引才会发生变化,新抽到的奖的面值才会被存到新数组newArr中.添加完毕后,移动索引
4.遍历newArr
import java.util.Random;
public class Test12 {
public static void main(String[] args) {
//1.定义数组表示奖池
int[] arr={2,588,888,1000,10000};
//2.定义新数组用于存储抽奖的结果
int[] newArr=new int[arr.length];
//3.抽奖
Random r=new Random();
for (int i = 0; i < 5; ) { //注意这里没有写i++
//获取随机索引
int randomIndex=r.nextInt(arr.length);
//获取奖项
int prize=arr[randomIndex];
//判断当前的奖项是否存在,如果存在则重新抽取,如果不存在,表示有效奖项
boolean flag=contains(newArr,prize);
//当抽到无效奖项时,不会运行下面的if语句,i的值不改变,会重新进入循环
if(!flag){
//把当前抽到的奖项添加到NewArr当中
newArr[i]=prize;
//添加完毕后,移动索引
i++; //只有当抽到的是有效奖项时,索引才会发生变化,新抽到的奖的面值才会被存到新数组newArr中
}
}
//4.遍历newArr
for (int i = 0; i < newArr.length; i++) {
System.out.println(newArr[i]);
}
}
// 定义方法判断prize在数组中是否存在
// 存在:true
// 不存在:false
public static boolean contains(int[] arr,int prize){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==prize){
return true;
}
}
return false;
}
}
这里需要注意:
当抽取最后一个奖项的时候,他被抽取的概率是1/数组的长度,在这道题中也就是20%,效率比较低.
如何优化一下算法呢?
思路二:
1.把奖池里面的所有奖项打乱顺序
2.遍历奖池
import java.util.Random;
public class Test13 {
public static void main(String[] args) {
// 1.把奖池里面的所有奖项打乱顺序
int[] arr={2,588,888,1000,10000};
Random r=new Random();
for (int i = 0; i < arr.length; i++) {
//后去随机索引
int randomIndex=r.nextInt(arr.length);
//拿着i和随机索引randomIndex上的值进行交换
int temp=arr[i];
arr[i]=arr[randomIndex];
arr[randomIndex]=temp;
}
// 2.遍历奖池,从0索引开始获取每一个奖项
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
思路二的方法不会出现无效奖项的情况,并且达到了将奖项打乱的效果.
十三、案例九：双色球彩票系统
思路:
1.随机生成中奖号码
2.用户输入彩票号码(红球+蓝球)
3.判断中奖情况
第一步随机生成中奖号码:
分析:
1.生成中奖号码,要用数组去存
2.定义生成中奖号码的方法:
(1)创建数组用于添加中奖号码
//6个红球 1个蓝球 数组长度:7
(2)随机生成号码并添加到数组中
红球:不能重复的生成
蓝球:可以和红球的号码重复
(3)生成红球号码并添加到数组中
随机获取红球号码
因为红球号码不能重复,所以拿着号码到arr数组中进行判断
所以写一个方法来判断
不存在,把红球号码添加到arr数组中
(4)生成蓝球号码添加到数组中的最大索引处
(5)返回数组
3.遍历数组
import java.util.Random;
public class Test14 {
public static void main(String[] args) {
//1.生成中奖号码
int[] arr=createNumber();
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
public static int[] createNumber() {
//1.创建数组用于添加中奖号码
//6个红球 1个蓝球 数组长度:7
int[] arr=new int[7];
// 2.随机生成号码并添加到数组中
// 红球:不能重复的生成
// 蓝球:可以和红球的号码重复
//生成红球号码并添加到数组中
Random r=new Random();
for (int i = 0; i < 6; ) {//注意这里没有i++
//获取红球号码
int redNumber=r.nextInt(33)+1;
// 因为红球号码不能重复,所以拿着号码到arr数组中进行判断
// 所以写一个方法来判断
boolean flag=contains(arr,redNumber);//将方法返回的结果定义一个变量接收
if(!flag){
//不存在,把红球号码添加到数组中
arr[i]=redNumber;
i++;
}
}
//生成蓝球号码添加到数组中的最大索引处
int blueNumber=r.nextInt(16)+1;
arr[arr.length-1]=blueNumber;
return arr;
}
//用于判断数字在数组中是否存在
public static boolean contains(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==number){
return true;
}
}
return false;
}
}
第二步用户输入彩票号码
分析:
1.创建数组用于添加用户购买的彩票号码
6个红球 1个蓝球 数组长度:7
2.利用键盘录入让用户输入
让用户输入红球号码:
(1)两个条件:要求redNumber要在1-33之间;并且唯一不重复
(2)第一个条件存在的情况下,判断第二个条件是不是唯一不重复的.有效的,可以添加到数组中;无效的,输出"当前号码已存在,请重新输入"
(3)第一个条件不存在的情况下,输出"当前红球号码超出范围"
让用户输入蓝球号码:
(1)随机生成蓝球号码
(2)判断蓝球号码在不在范围内:
在的话将号码赋值给数组的最大索引处并跳出while循环,不在的话,输出提示语句当前蓝球号码超出范围,并再次进入while循环,让用户重新输入蓝球的号码
import java.util.Random;
import java.util.Scanner;
public class Test14 {
public static void main(String[] args) {
//1.生成中奖号码
int[] arr = createNumber();
//2.用户输入彩票号码(红球+蓝球)
int[] uesrInputArr=userInputNumber();
//遍历用户输入的彩票号码
for (int i = 0; i < uesrInputArr.length; i++) {
System.out.print(uesrInputArr[i]+" ");
}
}
public static int[] userInputNumber() {
//1.创建数组用于添加用户购买的彩票号码
//6个红球 1个蓝球 数组长度:7
int[] arr = new int[7];
//2.利用键盘录入让用户输入
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length-1; ) {
//让用户输入红球号码
System.out.println("请输入第" + (i + 1) + "个红球号码");
int redNumber = sc.nextInt();
//要求redNumber要在1-33之间;并且唯一不重复
if (redNumber >= 1 && redNumber <= 33) {
//第一个条件存在的情况下,判断第二个条件是不是唯一不重复的
boolean flag = contains(arr, redNumber);
if (!flag) {
//不存在
//表示有效的,可以添加到数组中
arr[i] = redNumber;
i++; //注意有效之后才可以存入数组中.i才可以变化,所以这个for循环那里没有i++
} else {
//存在
System.out.println("当前号码已存在,请重新输入");
}
} else {
System.out.println("当前红球号码超出范围");
}
}
while (true) {
//让用户输入蓝球号码
System.out.println("请输入蓝球号码:");
//1~16
int blueNumber=sc.nextInt();
if (blueNumber >= 1 && blueNumber <= 16) {
arr[arr.length - 1] = blueNumber;
break; //猜对了就跳出循环
} else {
System.out.println("当前蓝球号码超出范围"); //如果超出范围了需要重新输入,所以要用一个循环
}
}
return arr;
}
public static int[] createNumber() {
//1.创建数组用于添加中奖号码
//6个红球 1个蓝球 数组长度:7
int[] arr=new int[7];
// 2.随机生成号码并添加到数组中
// 红球:不能重复的生成
// 蓝球:可以和红球的号码重复
//生成红球号码并添加到数组中
Random r=new Random();
for (int i = 0; i < 6; ) {
//获取红球号码
int redNumber=r.nextInt(33)+1;
// 因为红球号码不能重复,所以拿着号码到arr数组中进行判断
// 所以写一个方法来判断
boolean flag=contains(arr,redNumber);//将方法返回的结果定义一个变量接收
if(!flag){
//不存在,把红球号码添加到数组中
arr[i]=redNumber;
i++;
}
}
//生成蓝球号码添加到数组中的最大索引处
int blueNumber=r.nextInt(16)+1;
arr[arr.length-1]=blueNumber;
return arr;
}
//用于判断数字在数组中是否存在
public static boolean contains(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==number){
return true;
}
}
return false;
}
}
第三步判断用户的中奖情况
分析:
1.定义一个红球的统计变量
2.定义一个蓝球的统计变量
默认是0,默认都没有中奖
3.判断红球的中奖情况
(1)注意for循环处的判断条件那里数组的长度要-1
(2)定义变量接收用户输入彩票号码方法的数组返回值
(3)遍历中奖号码的数组与返回的数组值比较,如果找到了,统计变量++,那么后面的数字就没有必要比较了,break跳出内循环,继续判断下一个红球号码是否中奖
4.判断蓝球的中奖情况
(1)定义变量接收用户输入彩票号码方法的数组返回值的最大索引处的数值
(2)比较中奖号码的数组的最大索引处的数值和接收到的数值,
一样的话,蓝球的统计变量++
5.可以打印红球和蓝球的中奖个数
6.if-else if语句根据红球的个数以及篮球的个数来判断中奖情况
7.为了更好地测试代码,最好在开始将彩票的中奖号码打印出来,以便于我们测试代码正确与否
import java.util.Random;
import java.util.Scanner;
public class Test14 {
public static void main(String[] args) {
//1.生成中奖号码
int[] arr = createNumber(); //123456 7
//测试的时候最好这样打印出来结果便于测试代码
System.out.println("*****************************");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println("");
System.out.println("*****************************");
//2.用户输入彩票号码(红球+蓝球)
int[] userInputArr=userInputNumber(); //654321
/*//遍历用户输入的彩票号码
for (int i = 0; i < userInputArr.length; i++) {
System.out.print(userInputArr[i]+" ");
}
*/
//3.判断用户的中奖状况
//红球 蓝球
//默认是0,默认都没有中奖
int redCount=0;
int blueCount=0;
//判断红球的中奖情况,注意for循环处的判断条件那里数组的长度要-1
for (int i = 0; i < userInputArr.length-1; i++) {
int redNumber= userInputArr[i];
for (int j = 0; j < arr.length-1; j++) { //这里数组的长度也要-1
if(redNumber==arr[j]){
redCount++;
break;
//如果找到了,那么后面的数字就没有必要比较了
//跳出内循环,继续判断下一个红球号码是否中奖
}
}
}
//判断蓝球的中奖情况
int blueNumber=userInputArr[userInputArr.length-1];
if(blueNumber==arr[arr.length-1]){
blueCount++;
}
//可以打印红球和蓝球的中奖个数
System.out.println("红球的中奖个数是:"+redCount);
System.out.println("蓝球的中奖个数是:"+blueCount);
//根据红球的个数以及篮球的个数来判断中奖情况
if(redCount==6&&blueCount==1){
System.out.println("恭喜你,中奖1000万");
} else if (redCount==6&&blueCount==0) {
System.out.println("恭喜你,中奖五百万");
} else if (redCount==5&&blueCount==1) {
System.out.println("恭喜你,中奖3000");
} else if ((redCount==5&&blueCount==0)||(redCount==4&&blueCount==1)) {
System.out.println("恭喜你,中奖200");
}else if ((redCount==4&&blueCount==0)||(redCount==3&&blueCount==1)) {
System.out.println("恭喜你,中奖10");
}else if ((redCount==2&&blueCount==1)||(redCount==1&&blueCount==1)||(redCount==0&&blueCount==1)) {
System.out.println("恭喜你,中奖5");
}else{
System.out.println("谢谢惠顾");
}
}
public static int[] userInputNumber() {
//1.创建数组用于添加用户购买的彩票号码
//6个红球 1个蓝球 数组长度:7
int[] arr = new int[7];
//2.利用键盘录入让用户输入
Scanner sc = new Scanner(System.in);
for (int i = 0; i < arr.length-1; ) {
//让用户输入红球号码
System.out.println("请输入第" + (i + 1) + "个红球号码");
int redNumber = sc.nextInt();
//要求redNumber要在1-33之间;并且唯一不重复
if (redNumber >= 1 && redNumber <= 33) {
//第一个条件存在的情况下,判断第二个条件是不是唯一不重复的
boolean flag = contains(arr, redNumber);
if (!flag) {
//不存在
//表示有效的,可以添加到数组中
arr[i] = redNumber;
i++; //注意有效之后才可以存入数组中.i才可以变化,所以这个for循环那里没有i++
} else {
//存在
System.out.println("当前号码已存在,请重新输入");
}
} else {
System.out.println("当前红球号码超出范围");
}
}
while (true) {
//让用户输入蓝球号码
System.out.println("请输入蓝球号码:");
//1~16
int blueNumber=sc.nextInt();
if (blueNumber >= 1 && blueNumber <= 16) {
arr[arr.length - 1] = blueNumber;
break; //猜对了就跳出循环
} else {
System.out.println("当前蓝球号码超出范围"); //如果超出范围了需要重新输入,所以要用一个循环
}
}
return arr;
}
public static int[] createNumber() {
//1.创建数组用于添加中奖号码
//6个红球 1个蓝球 数组长度:7
int[] arr=new int[7];
// 2.随机生成号码并添加到数组中
// 红球:不能重复的生成
// 蓝球:可以和红球的号码重复
//生成红球号码并添加到数组中
Random r=new Random();
for (int i = 0; i < 6; ) { //注意这里不要i++
//获取红球号码
int redNumber=r.nextInt(33)+1;
// 因为红球号码不能重复,所以拿着号码到arr数组中进行判断
// 所以写一个方法来判断
boolean flag=contains(arr,redNumber);//将方法返回的结果定义一个变量接收
if(!flag){
//不存在,把红球号码添加到数组中
arr[i]=redNumber;
i++;
}
}
//生成蓝球号码添加到数组中的最大索引处
int blueNumber=r.nextInt(16)+1;
arr[arr.length-1]=blueNumber;
return arr;
}
//用于判断数字在数组中是否存在
public static boolean contains(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(arr[i]==number){
return true;
}
}
return false;
}
}
总结
今天的内容你是否有所收获呢友友们🥰如果有写的不对的地方,欢迎大家帮我指正.最后,希望友友们点赞收藏一下博客关注后续的Java学习内容哦~😘💕💕
