• Java实验案例（一）

    目录

    案例一：买飞机票

    案例二：开发验证码

    案例三：评委打分

    案例四：数字加密

    案例五：数组拷贝

    案例六：抢红包

    案例七：找素数的三种方法

    案例八：打印乘法口诀表

    案例九：打印三角形

    案例十：模拟双色球

    案例一：买飞机票

    我的思考：

     用 if 语句分割开淡旺季，再分别在淡旺季中区分两种舱的价格。

    我的初步代码：

     逻辑非常简单，没有问题，但是感觉代码写的冗余不清晰，明明非常简单的几步感觉被复杂化了，所以写代码必须简洁明了，简单易懂。

    尤其时main函数主体内的代码要少，几行之内搞定是最好的，可以将繁冗的代码封装成方法，减少main函数中的代码：

    案例二：开发验证码

     

    我的思考：

    首先，生成的验证码位数是需要我们输入确定的。每一位可以用一个字符表示（数字就是数字字符 '0' ~ '9'），可以用随机数确定每一位是数字字符还是大小写字母。

    每一位可以通过字符串拼接的方式 ' + ' 来实现单个字符变成字符串。

    数字字符容易用随机数生成，大小写字母其实就是ASCLL码，也可以通过随机数生成。

    我的代码：

    案例三：评委打分

     

    案例四：数字加密

    我的思考：

    首先输入的是字符串，在字符串中改变每一位数字并不方便，于是我设置了一个字符数组接收字符串，对每一位的数字进行算术运算字符并不好处理，于是我设置了一个整型临时变量，循环地处理每一位的算术运算，再将算好的整型数字转化成字符放到字符数组中去。返回数组的地址，在main函数中用一个字符串接收，最后打印出来。

    我的代码： 

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         Scanner sc = new Scanner(System.in);
    4.         System.out.println("请输入原始密码：");
    5.         String ori_code = sc.next();
    6.         String codes = new String(encryption(ori_code));
    7.         System.out.println("加密后的密码是：" + codes);
    8.     }
    9.  
    10.     public static char[] encryption(String ori_code){
    11.         assert(ori_code != null);
    12.         char[] code = new char[ori_code.length()];
    13.         for (int i = 0; i < code.length; i++) {
    14.             int temp = 0;
    15.             temp = ori_code.charAt(i)-'0';
    16.             temp += 5;
    17.             temp %= 10;
    18.             code[i] = (char)(temp+'0');
    19.         }
    20.         for(int i = 0,j = ori_code.length()-1;i < j;i++,j--){
    21.             char tmp = code[i];
    22.             code[i] = code[j];
    23.             code[j] = tmp;
    24.         }
    25.         return code;
    26.     }
    27. }

    案例五：数组拷贝

     我的思考：

    复制一个内容一样的数组很容易，关键在于这题需要的是一模一样的数组，那也就是说连地址都相同，所以需要把旧数组的地址赋给新数组。

    我的代码：

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         int[] arr = {11,22,33};
    4.         System.out.println(Arrays.toString(copy(arr)));
    5.     }
    6.     public static int[] copy(int[] arr){
    7.         int[] copy_arr = new int[arr.length];
    8.         copy_arr = arr;
    9.         for (int i = 0; i < arr.length; i++) {
    10.             copy_arr[i] = arr[i];
    11.         }
    12.         System.out.println(copy_arr);
    13.         System.out.println(arr);
    14.         return copy_arr;
    15.     }
    16. }

     

    案例六：抢红包

    我的思考：

    一共有五个数据，可以存放在整型数组中，用switch语句分别处理每种抽到的情况，用随机数控制switch语句的执行。

    关键在于每个数只能抽到一次，可以在循环中处理重复情况。（我没想到简便的处理方法，就是很僵硬地设置了5个计数器分别对应5种抽奖结果，抽到过地break）

    我的代码：

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         int[] arr = {9,666,188,520,99999};
    4.         extractRedEnvelopes(arr);
    5.     }
    6.     public static void extractRedEnvelopes(int[] arr){
    7.         System.out.println("有五个红包，分别是9，666，188，520，99999的");
    8.         System.out.println("现在开始直播抽取红包");
    9.         Random r = new Random();
    10.         int count1 = 0,count2 = 0,count3 = 0,count4 = 0,count5 = 0;
    11.         while(count1 + count2 + count3 + count4 + count5 != 5){
    12.             System.out.println("请按任意键开始抽奖");
    13.             Scanner sc = new Scanner(System.in);
    14.             String s = sc.next();
    15.             if (s.equals("1")) {
    16.                 int random = r.nextInt(5); //0~4
    17.                 switch (random) {
    18.                     case 0:
    19.                         if (count1 == 1)
    20.                         {
    21.                             System.out.println("很抱歉，你没抽到");
    22.                             break;
    23.                         }
    24.                         System.out.println("恭喜你，你抽到了，" + 6);
    25.                         count1++;
    26.                         break;
    27.                     case 1:
    28.                         if (count2 == 1)
    29.                         {
    30.                             System.out.println("很抱歉，你没抽到");
    31.                             break;
    32.                         }
    33.                         System.out.println("恭喜你，你抽到了，" + 188);
    34.                         count2++;
    35.                         break;
    36.                     case 2:
    37.                         if (count3 == 1)
    38.                         {
    39.                             System.out.println("很抱歉，你没抽到");
    40.                             break;
    41.                         }
    42.                         System.out.println("恭喜你，你抽到了，" + 666);
    43.                         count3++;
    44.                         break;
    45.                     case 3:
    46.                         if (count4 == 1)
    47.                         {
    48.                             System.out.println("很抱歉，你没抽到");
    49.                             break;
    50.                         }
    51.                         System.out.println("恭喜你，你抽到了，" + 520);
    52.                         count4++;
    53.                         break;
    54.                     case 4:
    55.                         if (count5 == 1)
    56.                         {
    57.                             System.out.println("很抱歉，你没抽到");
    58.                             break;
    59.                         }
    60.                         System.out.println("恭喜你，你抽到了，" + 99999);
    61.                         count5++;
    62.                         break;
    63.                     default:
    64.                         System.out.println("出错了，请重试");
    65.                         break;
    66.                 }
    67.             } else {
    68.                 System.out.println("请输入正确的键以开始抽奖");
    69.                 return;
    70.             }
    71.         }
    72.  
    73.     }
    74. }

     可以看到代码十分冗余繁杂，来看看老师是怎么实现的：

    下面有两种方案，方案一和上面类似，都存在效率低下，可能多次重复寻找的问题。

    方案一：

    数组中每个位置的值代表红包金额，取的时候看该位置值是否为0，是0则继续循环寻找；不是0则取该数并将该位置的值置为0.

    代码：

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         int[] arr = {9,666,188,520,99999};
    4.         extractRedEnvelopes(arr);
    5.     }
    6.     public static void extractRedEnvelopes(int[] arr){
    7.         System.out.println("有五个红包，分别是9，666，188，520，99999的");
    8.         System.out.println("现在开始直播抽取红包");
    9.         for (int i = 0; i < arr.length; i++) {
    10.             System.out.println("输入任意内容开始抢红包");
    11.             Scanner sc = new Scanner(System.in);
    12.             sc.next();
    13.             while (true){
    14.                 Random r = new Random();
    15.                 int money = r.nextInt(arr.length);
    16.                 if(arr[money] != 0){
    17.                     System.out.println("恭喜你，你抢到了"+arr[money]);
    18.                     arr[money] = 0;
    19.                     break;
    20.                 }
    21.                 else{
    22.                     System.out.println("抱歉，你没抢到");
    23.                 }
    24.             }
    25.         }
    26.     }
    27. }

    方案二：

    可以将初始红包的顺序打乱，也就是将数组中的数据顺序打乱，然后根据先来后到分配给抢红包的用户，这样有多少个红包就是分发多少次，不会出现重复查找效率低下的情况。

    那么关键就在于打乱数组数据，可以依次遍历数组元素，根据随机索引调换数据位置，以达到打乱数据的效果。

    代码：

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         extractRedEnvelopes();
    4.     }
    5.     public static void extractRedEnvelopes(){
    6.         System.out.println("有五个红包，分别是9，666，188，520，99999的");
    7.         System.out.println("现在开始直播抽取红包");
    8.         System.out.println("输入任意内容开始抽取");
    9.         int[] arr = {9,666,188,520,99999};
    10.         disruptingData (arr); //打乱数组数据
    11.         Scanner sc = new Scanner(System.in);
    12.         sc.next();
    13.         for (int i = 0; i < arr.length; i++) {
    14.             System.out.println("恭喜"+(i+1)+"号观众,"+"你抽到了"+arr[i]);
    15.         }
    16.     }
    17.     public static void disruptingData(int[] arr){
    18.         Random r = new Random();
    19.         for (int i = 0; i < arr.length; i++) {
    20.             int ran = r.nextInt(arr.length);
    21.             int tmp = arr[i];
    22.             arr[i] = arr[ran];
    23.             arr[ran] = tmp;
    24.         }
    25.         }
    26. }

    案例七：找素数的三种方法

    我的思考：

    素数是除了1和自己本身，其他数都不能整除的数。那么就依次遍历101~200的每个数，用2~ (i-1)的数去尝试能否被整除，不能就是素数。

    我的代码：

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         findingPrimeNumbers();
    4.         }
    5.         public static void findingPrimeNumbers(){
    6.         int[] arr = new int[100];
    7.         int k = 0;
    8.             for (int i = 101; i < 200; i++) {
    9.                 int flag = 1;
    10.                 for(int j = 2; j < i-1; j++){
    11.                     if(i % j == 0) {
    12.                         flag = 0;
    13.                         break;
    14.                     }
    15.                 }
    16.                 if(flag == 1)  arr[k++] = i;
    17.  
    18.             }
    19.             System.out.println(Arrays.toString(arr));
    20.     }
    21. }

    这段代码效率低，因为进行了多余操作，其实不用将 2~ (i-1）的数都试一遍的，只需要一半的数字足矣。

    下面来看一下老师的代码：

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         System.out.println("请输入要查找的素数范围：");
    4.         Scanner sc = new Scanner(System.in);
    5.         int start = sc.nextInt();
    6.         int end = sc.nextInt();
    7.         int count = findingPrimeNumbers(start,end);
    8.         System.out.println("素数的个数为" + count);
    9.         }
    10.         public static int findingPrimeNumbers(int start,int end) {
    11.             assert (start > 0 && end > 0 && start < end);
    12.             int count = 0;
    13.             for (int i = start; i <= end; i++) {
    14.                 boolean flag = true;
    15.                 for (int j = 2; j < i / 2; j++) {
    16.                     if (i % j == 0) {
    17.                         flag = false;
    18.                         break;
    19.                     }
    20.                 }
    21.                 if (flag == true) {
    22.                     System.out.println("素数有" + i + " ");
    23.                     count++;
    24.                 }
    25.             }
    26.             return count;
    27.         }
    28. }

     方案三

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         System.out.println("请输入要查找的素数范围：");
    4.         Scanner sc = new Scanner(System.in);
    5.         int start = sc.nextInt();
    6.         int end = sc.nextInt();
    7.         for(int i = start;i <= end; i++){
    8.             if(findingPrimeNumbers(i)) System.out.println(i+"是素数");
    9.         }
    10.         }
    11.         public static boolean findingPrimeNumbers(int num) {
    12.             for(int i = 2;i < num/2; i++){
    13.                 if(num % i == 0) return false;
    14.             }
    15.             return true;
    16.         }

    这种方案就是先建立一个判断是否为素数的方法，来一个数就放到该方法中判断，更加方便，也更贴近工作中编程的思想。

    案例八：打印乘法口诀表

    我的思考：

    主要是注意一个格式，内层循环外层循环的嵌套。外层行，内层列。

    我的代码： 

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         for(int i = 1;i <= 9;i++){
    4.             for(int j = 1;j <= i;j++){
    5.                 System.out.print(j+" * "+i+" = "+i*j+"  ");
    6.             }
    7.             System.out.println();
    8.         }
    9.     }
    10. }

    案例九：打印三角形

    我的思考：

    第一行：3空格+ 1星

    第二行：2空格+3星

    第三行：1空格+5星

    第四行：0空格+7星

    我的代码：

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         for(int i = 1;i <= 4;i++){
    4.             for(int j = 1;j <= (4-i);j++){
    5.                 System.out.print(" ");
    6.             }
    7.             for (int j = i; j <= (2*i-1) ; j++) {
    8.                 System.out.print("*");
    9.             }
    10.             System.out.println();
    11.         }
    12.     }
    13. }

    案例十：模拟双色球

     

     我的思考：

    如上图所示，三色球的实现需要三个方法：用户投注号码，中奖标准号码，判断中几等奖。

    可以将投注号码和中奖号码存在数组中返回，最终比较投注号码和中奖号码以判断中奖情况。

    我的代码：

    第一次理解错了，以为是每一等中奖号码要手动输入，麻烦了很多。

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         int[] userNumbers = userSelectNumbers();
    4.         String[] luckNumbers = creatLuckNumbers();
    5.         judge(userNumbers,luckNumbers);
    6.     }
    7.     public static int[] userSelectNumbers(){
    8.         int[] userNumbers = new int[7];
    9.         System.out.println("请输入你的投注号码，前6位1~33，最后一位1~16");
    10.         Scanner sc = new Scanner(System.in);
    11.         for (int i = 0; i < userNumbers.length; i++) {
    12.             userNumbers[i] = sc.nextInt();
    13.             assert(userNumbers[i] > 0 && userNumbers[i] < 34);
    14.             assert (userNumbers[6] > 0 && userNumbers[6] < 17);
    15.         }
    16.         return userNumbers;
    17.     }
    18.     public static String[] creatLuckNumbers(){
    19.         String[] luckNumbers = new String[9];
    20.         int[] eachNumbers = new int[7];
    21.         for (int k = 0; k < luckNumbers.length; k++) {
    22.             System.out.println("请输入第"+(k+1)+"级中奖号码：");
    23.             Scanner sc = new Scanner(System.in);
    24.             for (int i = 0; i < eachNumbers.length; i++) {
    25.                 eachNumbers[i] = sc.nextInt();
    26.                 assert(eachNumbers[i] > 0 && eachNumbers[i] < 34);
    27.                 assert (eachNumbers[8] > 0 && eachNumbers[8] < 17);
    28.             }
    29.             luckNumbers[k] = Arrays.toString(eachNumbers);
    30.             System.out.println((k+1)+"级中奖号码是："+ Arrays.toString(eachNumbers));
    31.         }
    32.         return luckNumbers;
    33.     }
    34.     public static void judge(int[] userNumbers,String[] luckNumbers){
    35.         for(int i = 0;i < luckNumbers.length;i++){
    36.             if(Arrays.toString(userNumbers).equals(luckNumbers[i])){
    37.                 switch (i){
    38.                     case 0:
    39.                         System.out.println("恭喜你，中了一等奖");
    40.                         break;
    41.                     case 1:
    42.                         System.out.println("恭喜你，中了二等奖");
    43.                         break;
    44.                     case 2,3:
    45.                         System.out.println("恭喜你，中了三等奖");
    46.                         break;
    47.                     case 4,5:
    48.                         System.out.println("恭喜你，中了四等奖");
    49.                         break;
    50.                     case 6,7:
    51.                         System.out.println("恭喜你，中了五等奖");
    52.                         break;
    53.                     case 8,9:
    54.                         System.out.println("恭喜你，中了六等奖");
    55.                         break;
    56.                 }
    57.             }
    58.             else System.out.println("很抱歉，你没中奖。");
    59.         }
    60.     }
    61. }

    改正：

    1. public class test_01 {
    2.     public static void main(String[] args) {
    3.         int[] userNumbers = userSelectNumbers();
    4.         int[] luckNumbers = creatLuckNumbers();
    5.         judge(userNumbers,luckNumbers);
    6.     }
    7.     public static int[] userSelectNumbers(){
    8.         int[] userNumbers = new int[7];
    9.         System.out.println("请输入你的投注号码，前6位1~33，最后一位1~16");
    10.         Scanner sc = new Scanner(System.in);
    11.         for (int i = 0; i < userNumbers.length; i++) {
    12.             userNumbers[i] = sc.nextInt();
    13.             if(userNumbers[i] < 1 || userNumbers[i] > 33) {
    14.                 System.out.println("请输入合法的号码");
    15.                 System.exit(-1);
    16.             }
    17.             for(int j = 0;j < i;j++){
    18.                 if(userNumbers[j] == userNumbers[i]) {
    19.                     System.out.println("请勿输入同样的号码！");
    20.                     break;
    21.                 }
    22.             }
    23.         }
    24.         if(userNumbers[6] < 1 || userNumbers[6] > 16) {
    25.             System.out.println("请输入合法的号码");
    26.             System.exit(-1);
    27.         }
    28.         return userNumbers;
    29.     }
    30.     public static int[] creatLuckNumbers(){
    31.         int[] luckNumbers = new int[7];
    32.         System.out.println("请输入中奖号码，前6位1~33，最后一位1~16");
    33.         Scanner sc = new Scanner(System.in);
    34.         for (int i = 0; i < luckNumbers.length; i++) {
    35.             luckNumbers[i] = sc.nextInt();
    36.             if(luckNumbers[i] < 1 || luckNumbers[i] > 33){
    37.                 System.out.println("请输入合法的号码");
    38.                 System.exit(-1);
    39.             }
    40.             for(int j = 0;j < i;j++) {
    41.                 if (luckNumbers[j] == luckNumbers[i]) {
    42.                     System.out.println("请勿输入同样的号码！");
    43.                     break;
    44.                 }
    45.             }
    46.         }
    47.         if(luckNumbers[6] < 1 || luckNumbers[6] > 16) {
    48.             System.out.println("请输入合法的号码");
    49.             System.exit(-1);
    50.         }
    51.         return luckNumbers;
    52.     }
    53.     public static void judge(int[] userNumbers,int[] luckNumbers){
    54.         int count = 6, flag = 1;
    55.         for (int i = 0; i < userNumbers.length-1; i++) {
    56.             if(userNumbers[i] != luckNumbers[i]) count--;
    57.         }
    58.         if(userNumbers[6] != luckNumbers[6]) flag = 0;
    59.         switch(count){
    60.             case 0,1:
    61.                 if(flag == 1)  System.out.println("恭喜，你中了六等奖");
    62.                 else  System.out.println("很抱歉，你没有中奖");
    63.                 break;
    64.             case 2,3:
    65.                 if(flag == 1) System.out.println("恭喜，你中了五等奖");
    66.                 else  System.out.println("很抱歉，你没有中奖");
    67.                 break;
    68.             case 4:
    69.                 if(flag == 1) System.out.println("恭喜，你中了四等奖");
    70.                 else  System.out.println("恭喜，你中了五等奖");
    71.                 break;
    72.             case 5:
    73.                 if(flag == 1) System.out.println("恭喜，你中了三等奖");
    74.                 else  System.out.println("恭喜，你中了四等奖");
    75.                 break;
    76.             case 6:
    77.                 if(flag == 1) System.out.println("恭喜，你中了一等奖");
    78.                 else  System.out.println("恭喜，你中了二等奖");
    79.                 break;
    80.             default:
    81.                 System.out.println("error");
    82.                 break;
    83.         }
    84.     }
    85. }

  • 相关阅读:
    order模块给User模块发送http请求
    亚马逊云科技二度亮相服贸会，又带来哪些前沿应用技术？
    21天打卡挑战 - 经典算法之直接插入排序
    Windows 常用快捷键
    C++ permutation排列算法详解(深入了解,一文学会)
    最小二乘法参数拟合
    以神龙出行小程序为例，说一些网站技术
    最新ChatGPT商业运营系统源码+支持GPT4/支持ai绘画+支持Midjourney绘画
    Linux下 man命令的使用 及 中文man手册的安装
    分布式理论基础：CAP定理
  • 原文地址：https://blog.csdn.net/SAKURAjinx/article/details/133136623