devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【java】【基础5】使用java基础知识实战案例_java 实战小案例

作者：知新_RL | 2024-05-11 20:42:01

赞

踩

java 实战小案例

目录

案例一：买飞机票

案例二：开发验证码

案例三：评委打分

案例四：数字加密

案例五：数组拷贝

案例六：抢红包

6.1 方案1

6.2 方案2

案例七：找素数

 7.1 方法1

 7.2 方法2

7.3 方法3

案例八：打印乘法表

案例九：打印三角形

案例十：模拟双色球[拓展案例]

10.1 业务分析、用户投注一组号码

10.2 随机生成一组中奖号码

10.3 判断中奖情况

前言：使用java学习的基础知识，进行案例实战

 

案例一：买飞机票

 

  1. package com.runa.define2;
  2.  
  3. public class MethodDemo9 {
  4.     public static void main(String[] args) {
  5.        double price = calculate(1000,6,"头等舱");
  6.         System.out.println("优惠价格是：" + price);
  7.     }
  8.     public static double calculate(double price, int month, String type){
  9.         // 1 判断当前月份是否淡季还是旺季
  10.         if(month >= 5 && month <= 10){
  11.             //旺季
  12.             //2 判断仓位类型
  13.             switch (type){
  14.                 case "头等舱":
  15.                     price *= 0.9;
  16.                     break;
  17.                 case "经济舱":
  18.                     price *= 0.85;
  19.                     break;
  20.             }
  21.         }else{
  22.             //淡季
  23.             //2 判断仓位类型
  24.             switch (type){
  25.                 case "头等舱":
  26.                     price *= 0.7;
  27.                     break;
  28.                 case "经济舱":
  29.                     price *= 0.65;
  30.                     break;
  31.             }
  32.         }
  33.         return price;
  34.     }
  35. }
  36.

 

 

案例二：开发验证码

 

  1. package com.runa.define2;
  2.  
  3. import java.util.Random;
  4.  
  5. public class MethodDemo10 {
  6.     public static void main(String[] args) {
  7.         System.out.println("当前生成的验证码为：" + creatCode(4));
  8.     }
  9.     public static String creatCode(int n){
  10.         // 1 定义一个for循环用于控制产生随机字符
  11.         Random r = new Random();
  12.         // 3 定义一个String类型的变量用于记住产生的每位随机字符
  13.         String code = "";
  14.         for (int i = 0; i < n; i++) {
  15.             // 2 为每个位置生成随机字符,可能是数字、大小写字母
  16.             // 思路： 随机一个 0  1  2之间的数字出来，0代表数字，1、2代表大、小写字母
  17.             int type = r.nextInt(3); //0 1 2
  18.             switch (type){
  19.                 case 0:
  20.                     // 随机一个数字字符
  21.                     code += r.nextInt(10); // 0  -  9 += 这里是连接的作用
  22.                     break;
  23.                 case 1:
  24.                     // 随机一个大写字符 A65 Z 65+25
  25.                     char ch1 = (char)(r.nextInt(26) + 65);
  26.                     code += ch1;
  27.                     break;
  28.                 case 2:
  29.                     // 随机一个小写字符 a 97  z 97+25
  30.                     char ch2 = (char)(r.nextInt(26) + 97);
  31.                     code += ch2;
  32.                     break;
  33.             }
  34.         }
  35.         return code;
  36.     }
  37. }

 

 

案例三：评委打分

 

  1. package com.runa.define2;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class MethodDemo11 {
  6.     public static void main(String[] args) {
  7.         System.out.println("当前选手得分是：" + getAveScore(6));
  8.     }
  9.     public static double getAveScore(int number){
  10.         //1 定义一个动态初始化的数组，负责存储后期存储的分数
  11.         int[] scores = new int[number];
  12.         Scanner sc = new Scanner(System.in);
  13.         // 2 遍历数组的每个位置，依次录入评委的分数
  14.         for (int i = 0; i < scores.length; i++) {
  15.             System.out.println("请您录入第" + (i + 1) + "个评委的分数：");
  16.             int sorce = sc.nextInt();
  17.             scores[i] = sorce;
  18.  
  19.         }
  20.         // 3 从数组当中计算出总分、最高分、最低分
  21.         int sum = 0;
  22.         int max = scores[0]; //最大值，使用数组的第一个数
  23.         int min = scores[0];//最小值，使用数组的第一个数
  24.  
  25.         // 遍历数组找出符合条件数据
  26.         for (int i = 0; i < scores.length; i++) {
  27.             int score = scores[i];
  28.             //求和
  29.             sum += scores[i];
  30.             // 求最大值
  31.             if(scores[i] > max){
  32.                 max = scores[i];
  33.             }
  34.             // 求最小值
  35.             if(scores[i] < min){
  36.                 min = scores[i];
  37.             }
  38.         }
  39.         // 4 计算平均分返回
  40.  
  41.          return 1.0 * (sum - max - min)/(number-2);
  42.     }
  43. }

 

 

案例四：数字加密

 

  1. package com.runa.define2;
  2.  
  3.  
  4.  
  5. public class MethodDemo12 {
  6.     public static void main(String[] args) {
  7.         System.out.println("加密后的结果是：" + ercrypt(1983));
  8.     }
  9.     public static String ercrypt(int number){
  10.         // 1 把密码拆分成一个一个的数字，才可以对其进行加密
  11.         int[] numbers = split(number);
  12.  
  13.         // 2 遍历这个数组中的每个数字，对其进行加密处理
  14.         for (int i = 0; i < numbers.length; i++) {
  15.             numbers[i] = (numbers[i] + 5) % 10;
  16.         }
  17.         // 3 对数组的数字进行反转，把对数组进行反转的操作交给一个独立的方法来完成
  18.         reverse(numbers);
  19.         // 4 把这些加密的数字拼接起来，作为加密后的结果返回
  20.         String data = "";
  21.         for (int i = 0; i < numbers.length; i++) {
  22.             data += numbers[i];
  23.             
  24.         }
  25.         return data;
  26.     }
  27.  
  28.     public static void reverse(int[] numbers) {
  29.         // 反转数组
  30.         for (int i = 0,j = numbers.length - 1; i < j; i++, j--) {
  31.             //  把后一位的值交给一个temp存储
  32.             int temp = numbers[j];
  33.             // 把前一个位置的值给后一位处
  34.             numbers[j] = numbers[i];
  35.             // 将temp赋值给前一个位置
  36.             numbers[i] = temp;
  37.         }
  38.     }
  39.  
  40.     public static int[] split(int number) {
  41.         // number =1983
  42.         int[] numbers = new int[4];
  43.         numbers[0] = number / 1000;
  44.         numbers[1] = (number / 100) % 10;
  45.         numbers[2] = (number / 10) % 10;
  46.         numbers[3] = number % 10;
  47.         return numbers;
  48.     }
  49. }

 

 

案例五：数组拷贝

 

  1. package com.runa.define2;
  2.  
  3. public class MethodDemo13 {
  4.     public static void main(String[] args) {
  5.         int[] arr = {11, 22, 33};
  6.         int[] arr2 = copy(arr);
  7.         printArray(arr2);
  8.     }
  9.     // 单独写一个一个方法打印数组内容
  10.     public static void printArray(int[] arr){
  11.         System.out.print("[");
  12.         for (int i = 0; i < arr.length; i++) {
  13.             System.out.print(i == arr.length - 1 ? arr[i]:arr[i] + ", ");
  14.         }
  15.         System.out.println("]");
  16.     }
  17.     public static int[] copy(int[] arr){
  18.         // arr = [11, 22, 33]
  19.         //1 创建一个长度一样的整型数组
  20.         int[] arr2 = new int[arr.length];
  21.         // 2 把原数组的元素对应位置赋值给新数组
  22.         for (int i = 0; i < arr.length; i++) {
  23.             arr2[i] = arr[i];
  24.  
  25.         }
  26.         //3 返回新数组
  27.         return arr2;
  28.     }
  29. }

 

 

案例六：抢红包

6.1 方案1

会存在性能问题

 

  1. package com.runa.define2;
  2.  
  3. import java.util.Random;
  4. import java.util.Scanner;
  5.  
  6. public class MethodDemo14 {
  7.     public static void main(String[] args) {
  8.         int[] arr = {9, 66, 188, 520, 9999};
  9.         start(arr);
  10.     }
  11.     public static void start(int[] moneys){
  12.         // moneys = [9, 66, 188, 520, 99999]
  13.         // 1 定义一个for循环，控制抽奖5次
  14.         Scanner sc = new Scanner(System.in);
  15.         Random r = new Random();
  16.         for (int i = 1; i <= 5; i++) {
  17.             // 2 提示粉丝抽奖
  18.             System.out.println("请您输入【任意内容】进行抽奖");
  19.             sc.next();//等待用户输入内容，按了回车才能往下走
  20.             // 3 为当前的这个分数找一个随机的红包出来
  21.             while (true) {
  22.                 int index = r.nextInt(moneys.length); // 0-4
  23.                 int money = moneys[index];
  24.  
  25.                 // 4 判断这个红包是否不为0
  26.                 if(money != 0){
  27.                     System.out.println("恭喜您，您抽中了红包：" + money);
  28.                     moneys[index] = 0;
  29.                     break;
  30.                 }
  31.             }
  32.  
  33.         }
  34.         System.out.println("活动结束！");
  35.     }
  36. }

6.2 方案2

 略

案例七：找素数

 7.1 方法1

  1. package com.runa.define2;
  2.  
  3. public class MthodDemo15 {
  4.     public static void main(String[] args) {
  5.         System.out.println("当前素数的个数是：" + search(101, 200));
  6.     }
  7.  
  8.     public static int search(int start, int end){
  9.         int count = 0;
  10.         //start = 101 end = 200
  11.         // 1 定义一个 for循环找到101到200之间的每个数据
  12.         for (int i = start; i <= end; i++) {
  13.             // 信号位思想
  14.             boolean flag = true;//假设的意思:默认认为当中i 记住的数据是素数
  15.  
  16.             // 2 判断当前i 这个数据是否是素数
  17.             for (int j = 2; j <= i / 2 ; j++) {
  18.                 if(i % j == 0){
  19.                     //i 当前记住的这个数据就不是素数
  20.                     flag = false;
  21.                     break;
  22.                 }
  23.             }
  24.  
  25.             // 3 根据判定的结果，决定是否输出i  ，是素数才能出展示
  26.             if(flag){
  27.                 System.out.println(i);
  28.                 count++;
  29.             }
  30.         }
  31.         return count;
  32.     }
  33. }

 

 7.2 方法2

使用标签技术

  1. package com.runa.define2;
  2.  
  3. public class MthodDemo15 {
  4.     public static void main(String[] args) {
  5.         search(101, 200);
  6.     }
  7.  
  8.     public static void search(int start, int end) {
  9.         int count = 0;
  10.         //start = 101 end = 200
  11.         // 1 定义一个 for循环找到101到200之间的每个数据
  12.         OUT:
  13.         for (int i = start; i <= end; i++) {
  14.  
  15.             // 2 拦截判断该数是否是素数
  16.             for (int j = 2; j <= i / 2; j++) {
  17.                 if (i % j == 0) {
  18.                     // 这个数不是素数不能打印
  19.                     continue OUT;// 结束外部循环的当次执行
  20.                 }
  21.             }
  22.             count++;
  23.             System.out.println(i);
  24.         }
  25.         System.out.println("个数" + count);
  26.     }
  27.  
  28. }

7.3 方法3

  1. package com.runa.define2;
  2.  
  3. public class MthodDemo15 {
  4.     public static void main(String[] args) {
  5.         int count = 0;
  6.         for (int i = 101; i <= 200; i++) {
  7.             if (check(i)) {
  8.                 System.out.println(i);
  9.                 count++;
  10.             }
  11.         }
  12.         System.out.println("素数的总数为：" + count);
  13.     }
  14.  
  15.     public static boolean check(int data) {
  16.  
  17.         for (int i = 2; i <= data / 2; i++) {
  18.             if (data % i == 0) {
  19.  
  20.                 return false;
  21.             }
  22.         }
  23.  
  24.  
  25.         return true;
  26.     }
  27.  
  28. }

案例八：打印乘法表

 

  1. package com.runa.define2;
  2.  
  3. public class MehodDemo16 {
  4.     public static void main(String[] args) {
  5.         // 1 定义一个for循环打印多少行
  6.         for (int i = 1; i <= 9 ; i++) {
  7.             // 2 定义一个内部循环，控制打印多少列
  8.             for (int j = 1; j <= i ; j++) {
  9.                 //
  10.                 System.out.print(j + "x" + i + "=" + j*i + "\t");
  11.  
  12.             }
  13.             System.out.println();//换行
  14.         }
  15.  
  16.     }
  17.  
  18. }

案例九：打印三角形

  1. package com.runa.define2;
  2.  
  3. public class MethodDemo17 {
  4.     public static void main(String[] args) {
  5.         // 1 先定义一个循环打印多少行
  6.         int n = 5;
  7.         for (int i = 1; i <= n; i++) {
  8.             //2 控制打印多少空格
  9.             for (int j = 1; j <= (n - i); j++) {
  10.                 System.out.print(" ");
  11.             }
  12.  
  13.             // 3 控制打印多少*
  14.             for (int j = 1; j <=(2 * i - 1); j++) {
  15.                 System.out.print(j % 2 == 0 ? " " : "*");
  16.             }
  17.             // 4 换行
  18.             System.out.println("");
  19.         }
  20.  
  21.     }
  22. }

  

案例十：模拟双色球[拓展案例]

10.1 业务分析、用户投注一组号码

 

  1. package com.runa.define2;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class MethodDemo18 {
  6.     public static void main(String[] args) {
  7.         int[] userNumbers = userSelectNumbers();
  8.         printArray(userNumbers);
  9.  
  10.  
  11.     }
  12.  
  13.     public static void printArray(int[] arr){
  14.         System.out.print("[");
  15.         for (int i = 0; i < arr.length; i++) {
  16.             System.out.print(i ==  arr.length - 1 ? arr[i] : arr[i] + ",");
  17.  
  18.         }
  19.         System.out.println("]");
  20.     }
  21.     // 1 用于让用户投注一组号码（前6个是红球，最后一个是篮球，并返回用户投注号码）
  22.     public static int[] userSelectNumbers() {
  23.         // 2 创建一个整型数组,用于存储用户投注的7个号码
  24.         int[] numbers = new int[7];
  25.         Scanner sc = new Scanner(System.in);
  26.         //3 遍历前6个位置，存入
  27.         for (int i = 0; i < numbers.length - 1; i++) {
  28.             //i = 0 1 2 3 4 5
  29.             // 4 开始让用户为当前位置投注一个红色号码(1-33)
  30.             while (true) {
  31.                 System.out.println("请您输入第" + (i + 1) + "个红色号码（1-33之间不能重复）：");
  32.                 int number = sc.nextInt();
  33.                 // 5 判断用户输入的红球号码是否在1-33之间
  34.                 if (number < 1 || number > 33) {
  35.                     System.out.println("对不起！ 您输入的红色球号码不再1-33之间，请重新输入！");
  36.                 } else {
  37.                     // 继续判断号码是否重复了
  38.                     if (exist(numbers, number)) {
  39.                         // number当前号码重复了
  40.                         System.out.println("对不起，请选择的号码重复了,请重新输入");
  41.                     } else {
  42.                         // number 可以使用
  43.                         numbers[i] = number;
  44.                         break;
  45.                     }
  46.                 }
  47.             }
  48.         }
  49.         //6 投注最后一个蓝色号码
  50.         while (true) {
  51.             System.out.println("请您输入最后一个蓝色号码（1-16）：");
  52.             int number = sc.nextInt();
  53.             // 判断用户输入的红球号码是否在1-16之间
  54.             if (number < 1 || number > 16) {
  55.                 System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
  56.             }else {
  57.                 // 蓝色球合法
  58.                 numbers[6] =number;
  59.                 break;
  60.             }
  61.         }
  62.         return numbers;
  63.     }
  64.  
  65.     public static boolean exist(int[] numbers, int number) {
  66.         // 判断number数字是否在数组numbers中存在
  67.         // numbers = [12,25,16,17,19,6]
  68.         // number = 14
  69.  
  70.         for (int i = 0; i < numbers.length; i++) {
  71.             // 优化，如果数组的元素是0就不找了
  72.             if(numbers[i] == 0){
  73.                 break;
  74.             }
  75.             // 判断数组元素是否等于输入的number
  76.             if(numbers[i] == number){
  77.                 return true;
  78.             }
  79.  
  80.         }
  81.         return false;
  82.  
  83.     }
  84.  
  85.  
  86. }

 

10.2 随机生成一组中奖号码

  1. package com.runa.define2;
  2.  
  3. import java.util.Random;
  4. import java.util.Scanner;
  5.  
  6. public class MethodDemo18 {
  7.     public static void main(String[] args) {
  8.         int[] userNumbers = userSelectNumbers();
  9.         printArray(userNumbers);
  10.         int[] luckNumbers = createLuckNumbers();
  11.         printArray(luckNumbers);
  12.  
  13.  
  14.     }
  15.  
  16.     public static void printArray(int[] arr){
  17.         System.out.print("[");
  18.         for (int i = 0; i < arr.length; i++) {
  19.             System.out.print(i ==  arr.length - 1 ? arr[i] : arr[i] + ",");
  20.  
  21.         }
  22.         System.out.println("]");
  23.     }
  24.     // 1 用于让用户投注一组号码（前6个是红球，最后一个是篮球，并返回用户投注号码）
  25.     public static int[] userSelectNumbers() {
  26.         // 2 创建一个整型数组,用于存储用户投注的7个号码
  27.         int[] numbers = new int[7];
  28.         Scanner sc = new Scanner(System.in);
  29.         //3 遍历前6个位置，存入
  30.         for (int i = 0; i < numbers.length - 1; i++) {
  31.             //i = 0 1 2 3 4 5
  32.             // 4 开始让用户为当前位置投注一个红色号码(1-33)
  33.             while (true) {
  34.                 System.out.println("请您输入第" + (i + 1) + "个红色号码（1-33之间不能重复）：");
  35.                 int number = sc.nextInt();
  36.                 // 5 判断用户输入的红球号码是否在1-33之间
  37.                 if (number < 1 || number > 33) {
  38.                     System.out.println("对不起！ 您输入的红色球号码不再1-33之间，请重新输入！");
  39.                 } else {
  40.                     // 继续判断号码是否重复了
  41.                     if (exist(numbers, number)) {
  42.                         // number当前号码重复了
  43.                         System.out.println("对不起，请选择的号码重复了,请重新输入");
  44.                     } else {
  45.                         // number 可以使用
  46.                         numbers[i] = number;
  47.                         break;
  48.                     }
  49.                 }
  50.             }
  51.         }
  52.         //6 投注最后一个蓝色号码
  53.         while (true) {
  54.             System.out.println("请您输入最后一个蓝色号码（1-16）：");
  55.             int number = sc.nextInt();
  56.             // 判断用户输入的红球号码是否在1-16之间
  57.             if (number < 1 || number > 16) {
  58.                 System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
  59.             }else {
  60.                 // 蓝色球合法
  61.                 numbers[6] =number;
  62.                 break;
  63.             }
  64.         }
  65.         return numbers;
  66.     }
  67.  
  68.     public static boolean exist(int[] numbers, int number) {
  69.         // 判断number数字是否在数组numbers中存在
  70.         // numbers = [12,25,16,17,19,6]
  71.         // number = 14
  72.  
  73.         for (int i = 0; i < numbers.length; i++) {
  74.             // 优化，如果数组的元素是0就不找了
  75.             if(numbers[i] == 0){
  76.                 break;
  77.             }
  78.             // 判断数组元素是否等于输入的number
  79.             if(numbers[i] == number){
  80.                 return true;
  81.             }
  82.  
  83.         }
  84.         return false;
  85.  
  86.     }
  87.  
  88.     // 系统随机一组中奖号码（前6个是红球，最后一个是篮球，并返回这组中奖号码）
  89.     public static int[] createLuckNumbers(){
  90.         // 1 创建一个整型数组,用于存储用户投注的7个号码
  91.         int[] numbers = new int[7];
  92.         Random r = new Random();
  93.         //2 遍历前6个位置，依次从（1-33之间）随机一个红球号码存入（不重复）
  94.         for (int i = 0; i < numbers.length - 1; i++) {
  95.             //i = 0 1 2 3 4 5
  96.             // 3 开始让用户为当前位置投注一个红色号码(1-33)
  97.             while (true) {
  98.                 int number = r.nextInt(33) + 1;
  99.                 //4 判断number是否重复,这样是不重复才进去
  100.                 if(!exist(numbers,number)){
  101.                     // number 正常可以使用
  102.                     numbers[i] = number;
  103.                     break;
  104.                 }
  105.             }
  106.         }
  107.         // 5 录入一个人蓝球号码 1-16
  108.         numbers[6] = r.nextInt(16) +1;
  109.         return numbers;
  110.     }
  111.  
  112.  
  113. }

 

 

10.3 判断中奖情况

  1. package com.runa.define2;
  2.  
  3. import java.util.Random;
  4. import java.util.Scanner;
  5.  
  6. public class MethodDemo18 {
  7.     public static void main(String[] args) {
  8.         int[] userNumbers = userSelectNumbers();
  9.         System.out.println("您投注的号码：");
  10.         printArray(userNumbers);
  11.         int[] luckNumbers = createLuckNumbers();
  12.         System.out.println("中奖号码：");
  13.         printArray(luckNumbers);
  14.         judge(userNumbers,luckNumbers);
  15.  
  16.     }
  17.  
  18.     public static void printArray(int[] arr){
  19.         System.out.print("[");
  20.         for (int i = 0; i < arr.length; i++) {
  21.             System.out.print(i ==  arr.length - 1 ? arr[i] : arr[i] + ",");
  22.  
  23.         }
  24.         System.out.println("]");
  25.     }
  26.     // 1 用于让用户投注一组号码（前6个是红球，最后一个是篮球，并返回用户投注号码）
  27.     public static int[] userSelectNumbers() {
  28.         // 2 创建一个整型数组,用于存储用户投注的7个号码
  29.         int[] numbers = new int[7];
  30.         Scanner sc = new Scanner(System.in);
  31.         //3 遍历前6个位置，存入
  32.         for (int i = 0; i < numbers.length - 1; i++) {
  33.             //i = 0 1 2 3 4 5
  34.             // 4 开始让用户为当前位置投注一个红色号码(1-33)
  35.             while (true) {
  36.                 System.out.println("请您输入第" + (i + 1) + "个红色号码（1-33之间不能重复）：");
  37.                 int number = sc.nextInt();
  38.                 // 5 判断用户输入的红球号码是否在1-33之间
  39.                 if (number < 1 || number > 33) {
  40.                     System.out.println("对不起！ 您输入的红色球号码不再1-33之间，请重新输入！");
  41.                 } else {
  42.                     // 继续判断号码是否重复了
  43.                     if (exist(numbers, number)) {
  44.                         // number当前号码重复了
  45.                         System.out.println("对不起，请选择的号码重复了,请重新输入");
  46.                     } else {
  47.                         // number 可以使用
  48.                         numbers[i] = number;
  49.                         break;
  50.                     }
  51.                 }
  52.             }
  53.         }
  54.         //6 投注最后一个蓝色号码
  55.         while (true) {
  56.             System.out.println("请您输入最后一个蓝色号码（1-16）：");
  57.             int number = sc.nextInt();
  58.             // 判断用户输入的红球号码是否在1-16之间
  59.             if (number < 1 || number > 16) {
  60.                 System.out.println("对不起！ 您输入的蓝色球号码不再1-16之间，请重新输入！");
  61.             }else {
  62.                 // 蓝色球合法
  63.                 numbers[6] =number;
  64.                 break;
  65.             }
  66.         }
  67.         return numbers;
  68.     }
  69.  
  70.     public static boolean exist(int[] numbers, int number) {
  71.         // 判断number数字是否在数组numbers中存在
  72.         // numbers = [12,25,16,17,19,6]
  73.         // number = 14
  74.  
  75.         for (int i = 0; i < numbers.length; i++) {
  76.             // 优化，如果数组的元素是0就不找了
  77.             if(numbers[i] == 0){
  78.                 break;
  79.             }
  80.             // 判断数组元素是否等于输入的number
  81.             if(numbers[i] == number){
  82.                 return true;
  83.             }
  84.  
  85.         }
  86.         return false;
  87.  
  88.     }
  89.  
  90.     // 系统随机一组中奖号码（前6个是红球，最后一个是篮球，并返回这组中奖号码）
  91.     public static int[] createLuckNumbers(){
  92.         // 1 创建一个整型数组,用于存储用户投注的7个号码
  93.         int[] numbers = new int[7];
  94.         Random r = new Random();
  95.         //2 遍历前6个位置，依次从（1-33之间）随机一个红球号码存入（不重复）
  96.         for (int i = 0; i < numbers.length - 1; i++) {
  97.             //i = 0 1 2 3 4 5
  98.             // 3 开始让用户为当前位置投注一个红色号码(1-33)
  99.             while (true) {
  100.                 int number = r.nextInt(33) + 1;
  101.                 //4 判断number是否重复,这样是不重复才进去
  102.                 if(!exist(numbers,number)){
  103.                     // number 正常可以使用
  104.                     numbers[i] = number;
  105.                     break;
  106.                 }
  107.             }
  108.         }
  109.         // 5 录入一个人蓝球号码 1-16
  110.         numbers[6] = r.nextInt(16) +1;
  111.         return numbers;
  112.     }
  113.  
  114.     // 传入两组号码，判断是否中奖，并输出
  115.     public static void judge(int[] userNumbers, int[] luckNumbers){
  116.         //userNumbers = [2,3,12,23,25,33,8]
  117.         //luckNumbers= [12,13,22,23,25,33,8]
  118.         // 1 分别定义两个遍历用于记住红球命中几个，蓝球命中几个
  119.         int redCount = 0;
  120.         int blueCount = 0;
  121.         // 2 先判断红球命中数量，遍历用户投注号码的前6个红球
  122.         for (int i = 0; i < userNumbers.length - 1; i++) {
  123.             // userNumbers[i]
  124.             //开始遍历中奖号码的前6红球号码，看用户当前选择的号码是否命中
  125.             for (int j = 0; j < luckNumbers.length - 1; j++) {
  126.                 if(userNumbers[i] == luckNumbers[j]){
  127.                     redCount++;
  128.                     break;
  129.                 }
  130.             }
  131.  
  132.         }
  133.         // 3 判断蓝球是否命中了
  134.         blueCount = userNumbers[6] == luckNumbers[6] ? 1 : 0;
  135.  
  136.         System.out.println("您命中的红球数量是：" + redCount);
  137.         System.out.println("您命中的蓝球数量是：" + blueCount);
  138.  
  139.         // 4 判断中奖详情，并输出结果
  140.         if(redCount == 6 && blueCount ==1){
  141.             System.out.println("恭喜你，中奖1000万，可以开始享受人生了~~~");
  142.         }else if(redCount == 6 && blueCount ==0){
  143.             System.out.println("恭喜你，中奖500万，可以稍微享受人生了~~~");
  144.         }else if(redCount == 5 && blueCount ==1){
  145.             System.out.println("恭喜你，中奖3000元，可以出去吃小龙虾了~~~");
  146.         }else if(redCount == 5 && blueCount ==0){
  147.             System.out.println("恭喜你，中奖200元~~");
  148.         }else if(redCount == 4 && blueCount ==0 || redCount == 3 && blueCount ==1){
  149.             System.out.println("恭喜你，中奖10元~");
  150.         }else if(redCount < 3 && blueCount ==1){
  151.             System.out.println("恭喜你，中奖5元~");
  152.         }else{
  153.             System.out.println("感谢您对福利事业做贡献~~~");
  154.         }
  155.     }
  156. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/556292
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号