【Java从入门到大牛】编程思维训练

本是古典何须时尚 2024-04-26 02:40 74阅读 0赞

> ? 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> ? 系列专栏：[Java从入门到大牛][Java]  
> ? 首发时间：2023年7月10日  
> ? 欢迎关注?点赞?收藏?留言?  
> ? 一以贯之的努力 不得懈怠的人生

#### 目录 ####

*  购买机票
 *  开发验证码
 *  评委打分
 *  数字加密
 *  数组拷贝
 *  找素数
 *  模拟双色球

## 购买机票 ##

**需求**

用户购买机票时，机票原价会按照淡季、旺季，头等舱还是经济舱的情况进行相应的优惠，优惠方案如下：5-10 月为旺季，头等舱 9 折，经济舱 8.5 折；11 月到来年 4 月为淡季，头等舱 7 折，经济舱 6.5 折，请开发程序计算出用户当前机票的优惠价

**分析**

*  方法需要接收机票原价、当前月份、舱位类型
 *  方法需要返回计算出的机票优惠价
 *  方法的内部业务：先使用 if 判断月份是旺季还是淡季，然后使用 switch 分支判断是头等舱还是经济舱

**代码示例**

// 购买机票
    public class Test1 {
        
        public static void main(String[] args) {
        
            double price = calculate(1000, 11, "头等舱");
            System.out.println("优惠价是：" + price);
        }
    
        public static double calculate(double price, int month, String type){
        
            // 1、判断当前月份是淡季还是旺季
            if(month >= 5 && month <= 10) {
             // 旺季
                // 2、判断舱位类型
                switch (type){
        
                    case "头等舱":
                        price *= 0.9; // price = price * 0.9;
                        break;
                    case "经济舱":
                        price *= 0.85;
                        break;
                }
            }else {
             // 淡季
                switch (type){
        
                    case "头等舱":
                        price *= 0.7;
                        break;
                    case "经济舱":
                        price *= 0.65;
                        break;
                }
            }
            return price;
        }
    }

**运行结果**

![在这里插入图片描述][f5f933fd20bb47dfa08cc0697b40172a.png]

## 开发验证码 ##

**需求**

开发一个程序，可以生成指定位数的验证码，每一位可以是数字或者大小写字母

**分析**

*  方法需要接收一个整数，来控制生成验证码的位数
 *  方法需要返回生成的验证码
 *  方法内部的业务：使用 for 循环依次生成每位随机字符，并使用一个 String 类型的变量把每个字符连接起来，最后返回该变量即可

**代码示例**

import java.util.Random;
    
    // 开发验证码
    public class Test2 {
        
        public static void main(String[] args) {
        
            System.out.println(createCode(8));
        }
    
        public static String createCode(int n){
        
            // 用于生成随机数
            Random r = new Random();
    
            // 定义一个String类型的变量用于记住产生的每位随机字符
            String code = "";
    
            // 定义一个for循环用于控制产生多少位随机字符
            for (int i = 1; i <= n; i++) {
        
                // 为每个位置生成一个随机字符：可能是数字、大小写字母。
                // 思路：随机一个0 1 2之间的数字出来，0代表随机一个数字字符，1代表随机大写字母，2代表随机小写字母
                int type = r.nextInt(3); // 0 1 2
                switch (type) {
        
                    case 0:
                        // 随机一个数字字符
                        code += r.nextInt(10); // 0 - 9  code = code + 8
                        break;
                    case 1:
                        // 随机一个大写字符 A 65   Z 65+25    (0 - 25) + 65
                        char ch1 = (char) (r.nextInt(26) + 65);
                        code += ch1;    // 连接起来
                        break;
                    case 2:
                        // 随机一个小写字符 a 97   z 97+25    (0 - 25) + 97
                        char ch2 = (char) (r.nextInt(26) + 97);
                        code += ch2;
                        break;
                }
            }
            return code;
        }
    }

**运行结果**

![在这里插入图片描述][6e9fa0c46a3e4e5db427be624ef6aadb.png]

## 评委打分 ##

**需求**

在歌唱比赛中，可能有多名评委给选手打分，分数是 \[0 - 100\] 之间的整数。选手的最后得分为：去掉最高分、最低分后剩余分数的平均分，请开发程序能够录入多名评委的分数，并算出选手的最终得分

**分析**

*  方法需要接收评委的人数
 *  方法需要返回计算出的选手最终得分
 *  方法内部的业务：定义数组，录入评委的分数存入到数组中去，接着，我们就需要遍历数组中的分数，计算出总分，并找出最高分和最低分，最后按照这些数据算出选手最终得分并返回即可

**代码示例**

import java.util.Scanner;
    
    // 评委打分
    public class Test3 {
        
        public static void main(String[] args) {
        
            System.out.println("当前选手得分是：" + getAverageScore(6));
        }
    
        public static double getAverageScore(int number){
        
            // 1、定义一个动态初始化的数组，负责后期存入评委的打分
            int[] scores = new int[number];
    
            // 2、遍历数组的每个位置，依次录入评委的分数
            Scanner sc = new Scanner(System.in);
            for (int i = 0; i < scores.length; i++) {
        
                System.out.print("请您录入第"+ (i + 1) +"个评委的分数：");
                scores[i] = sc.nextInt();
            }
    
            // 3、从数组中计算出总分，找出最高分，最低分。
            int sum = 0;         // 总分
            int max = scores[0]; // 最高分
            int min = scores[0]; // 最低分
    
            for (int i = 0; i < scores.length; i++) {
        
                int score = scores[i];
                // 求和
                sum += score;
    
                // 求最大值
                if(score > max){
        
                    max = score;
                }
    
                // 求最小值
                if(score < min){
        
                    min = score;
                }
            }
    
            // 4、计算出平均分并返回
            return 1.0 * (sum - min - max) / (number - 2);
        }
    }

**运行结果**

![在这里插入图片描述][3add3b4b23c84edea0a97798fb4230f7.png]

## 数字加密 ##

**需求**

某系统的数字密码是一个四位数，如 1983，为了安全，需要加密后再传输，加密规则是：对密码中的每位数，先加 5，再对 10 求余，最后将所有数字顺序反转，得到一串加密后的新数，请设计出满足本需求的加密程序

**分析**

*  方法需要接收四位数字密码
 *  方法需要返回加密后的结果
 *  方法内部的业务：将四位数字密码拆分成一个一个的数字，存入到数字中去，遍历数组中的每个数字，按照题目需求进行加密，最后再把加密后的数字拼接起来返回即可

**代码示例**

// 数字加密
    public class Test4 {
        
        public static void main(String[] args) {
        
            System.out.println("加密后的结果是：" + encrypt(8346));
        }
    
        public static String encrypt(int number){
        
            // 1、把密码拆分成一个一个的数字，才可以进行加密，把拆分功能写成一个方法
            int[] numbers = split(number);
    
            // 2、遍历数组中的每个数字，对其进行加密处理
            for (int i = 0; i < numbers.length; i++) {
        
                numbers[i] = (numbers[i] + 5) % 10;
            }
    
            // 3、对数组反转，把对数组进行反转的操作交给一个独立的方法来完成
            reverseArray(numbers);
    
            // 4、把这些加密的数字拼接起来做为加密后的结果返回即可。
            String data = "";
            for (int i = 0; i < numbers.length; i++) {
        
                data += numbers[i];
            }
            return data;
        }
    
        // 把一个字符串拆分成一个字符数组
        public static int[] split(int number) {
        
            int[] numbers = new int[4];
            numbers[0] = number / 1000;
            numbers[1] = (number / 100) % 10;
            numbers[2] = (number / 10) % 10;
            numbers[3] = number % 10;
            return numbers;
        }
    
        // 反转数组
        public static void reverseArray(int[] numbers) {
        
            for (int i = 0, j = numbers.length - 1; i < j; i++,j--) {
        
                // 交换i和j位置处的值
                // 1、把后一个位置处的值交给一个临时变量先存起来
                int temp = numbers[j];
                // 2、把前一个位置处的值赋值给后一个位置处
                numbers[j] = numbers[i];
                // 3、把后一个位置处原来的值（由临时变量记住着）赋值给前一个位置
                numbers[i] = temp;
            }
        }
    }

**运行结果**

![在这里插入图片描述][b18325f0066b4fb7a9f09f747342bf2e.png]

## 数组拷贝 ##

**需求**

请把一个整型数组，例如存了数据：11、22、33，拷贝成一个一模一样的新数组出来。注意：拷贝数组不是把原来的数组赋值给一个新的变量

**分析**

*  方法需要接收一个整型数组
 *  方法需要返回一个新的、一模一样的数组
 *  方法内部的业务：创建一个长度一样的整型数组作为新数组，并把原数组的元素对应位置赋值给新数组，最终返回新数组即可

**代码示例**

// 数组拷贝
    public class Test5 {
        
        public static void main(String[] args) {
        
            int[] arr1 = {
        11, 22, 33};
            int[] arr2 = copy(arr1);
            printArray(arr2);
    
            arr2[0] = 666;
            printArray(arr2);
            System.out.println(arr1[0]);
        }
        
        // 拷贝数组
        public static int[] copy(int[] arr){
        
            // 1、创建一个长度一样的整型数组出来
            int[] arr2 = new int[arr.length];
    
            // 2、把原数组的元素值对应位置赋值给新数组
            for (int i = 0; i < arr.length; i++) {
        
                arr2[i] = arr[i];
            }
    
            return arr2;
        }
        
        // 打印数组
        public static void printArray(int[] arr){
        
            System.out.print("[");
            for (int i = 0; i < arr.length; i++) {
        
                // 最后一个元素不要加逗号
                System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
            }
            System.out.println("]");
        }
    }

**运行结果**

![在这里插入图片描述][f2b82452890d42f78123abc9cdb15a09.png]

## 找素数 ##

**需求**

判断 101-200 之间的有多少个素数，并输出所有素数

说明：除了 1 和它本身以外，不能被其他正整数整除的数为素数

**分析**

*  方法需要接收 101 以及 200，以便查找该区间中的素数
 *  方法需要返回找到的素数个数
 *  方法内部的业务：使用 for 循环来产生 101 到 200 之间的每个数；每拿到一个数，判断该数是否是素数；判断规则是：从 2 开始遍历到该数的一半的数据，看看是否有数据可以整除它，有则不是素数，没有则是素数；根据判定的结果来决定是否输出该数；最后还需要统计素数的个数并返回

**代码示例**

// 找素数
    public class Test6 {
        
        public static void main(String[] args) {
        
            System.out.println("当前素数的个数是：" + search(101, 200));
        }
    
        public static int search(int start, int end){
        
            int count = 0;
            // 1、定义一个for循环找到101到200之间的每个数据
            for (int i = start; i <= end ; i++) {
        
                // 信号位思想
                boolean flag = true; // 默认认为当前i记住的数据是素数
    
                // 2、判断当前i记住的这个数据是否是素数
                for (int j = 2; j <= i / 2; j++) {
        
                    if(i % j == 0){
        
                        flag = false;   // i当前记住的这个数据不是素数了
                        break;
                    }
                }
    
                // 3、根据判定的结果决定是否输出i当前记住的数据：是素数才输出展示。
                if(flag){
        
                    System.out.print(i + " ");
                    count++;
    
                    // 每5个换一行
                    if (count % 5 == 0) {
        
                        System.out.println();
                    }
                }
            }
            System.out.println();
            return count;
        }
    }

**运行结果**

![在这里插入图片描述][0b1330d934a84c31a528913b28c91316.png]

## 模拟双色球 ##

**双色球业务介绍**

投注号码由 6 个红色球和 1 个蓝色球号码组成。红色球号码从 1-33 中选择；蓝色球号码从 1-16 中选择；只要投注号码与开奖号码相同，即可中奖，号码顺序不限

![在这里插入图片描述][de465bba889949069844e2f05918eb7a.png]

**总体框架分析**

public class Test7 {
        
    	public static void main(String[] args) {
        
    		int[] userNumbers = userSelectNumbers();
    		int[] luckNumbers = createLuckNumbers();
    		judge(userNumbers, luckNumbers);
    	}
    
    	/** 1、设计一个方法，用于让用户投注一组号码并返回（前6个是红球号码，最后1个是蓝球号码 ）*/
        public static int[] userSelectNumbers(){
        ...}
    
    	/** 2、设计一个方法：随机一组中奖号码出来（6个红球号码，1个蓝球号码 ）*/
        public static int[] createLuckNumbers(){
        ...}
    
    	/** 3、设计一个方法，用于判断用户的中奖情况 */
        public static void judge(int[] userNumbers,int[] luckNumbers){
        ...}
    }

**代码示例**

import java.util.Random;
    import java.util.Scanner;
    
    // 模拟双色球
    public class Test7 {
        
        public static void main(String[] args) {
        
            int[] userNumbers = userSelectNumbers();    // 投注号码
            System.out.println("您投注的号码：");
            printArray(userNumbers);
    
            int[] luckNumbers = createLuckNumbers();    // 中奖号码
            System.out.println("中奖的号码：");
            printArray(luckNumbers);
    
            judge(userNumbers, luckNumbers);            //开奖
    
        }
    
        /** 1、设计一个方法，用于让用户投注一组号码并返回（前6个是红球号码，最后1个是蓝球号码 ）*/
        public static int[] userSelectNumbers(){
        
            // 创建一个整型数组，用于存储用户投注的7个号码（前6个是红球号码，最后1个是蓝球号码 ）
            int[] numbers =  new int[7];    // 初始值都是0
            Scanner sc = new Scanner(System.in);
    
            // 遍历前6个位置，让用户依次投注6个红球号码，存入
            for (int i = 0; i < numbers.length - 1; i++) {
        
                while (true) {
        
                    // 开始让用户为当前位置投注一个红球号码（1-33之间，不能重复）
                    System.out.print("请您输入第" + (i + 1) + "个红球号码（1-33之间，不能重复）：");
                    int number = sc.nextInt();
    
                    // 先判断用户输入的红球号码是否在1-33之间
                    if(number < 1 || number > 33){
        
                        System.out.println("对不起，您输入的红球号码不在1-33之间，请确认！");
                    }else {
        
                        // 号码是在1-33之间了，接着还要继续判断这个号码是否重复，不重复才可以使用
                        if(exist(numbers, number)){
        
                            System.out.println("对不起，您当前输入的红球号码前面选择过，重复了，请确认！");
                        }else {
        
                            // number记住的这个号码没有重复了，就可以使用了
                            numbers[i] = number;
                            break;  // 结束当次投注，结束了当前死循环
                        }
                    }
                }
            }
    
            // 投注最后一个蓝球号码
            while (true) {
        
                System.out.print("请您输入最后1个蓝球号码（1-16）：");
                int number = sc.nextInt();
                if(number < 1 || number > 16){
        
                    System.out.println("对不起，您输入的蓝球号码范围不对！");
                }else {
        
                    numbers[6] = number;
                    break; // 蓝球号码录入成功，结束死循环
                }
            }
    
            return numbers;
        }
    
        // 判断红色球号码是否已投注
        private static boolean exist(int[] numbers, int number) {
        
            // 需求：判断number这个数字是否在numbers数组中存在
            for (int i = 0; i < numbers.length; i++) {
        
                if(numbers[i] == 0){
            // 说明还没元素存入
                    break;
                }
                if(numbers[i] == number){
        
                    return true;
                }
            }
            return false;
        }
    
        // 打印数组
        public static void printArray(int[] arr) {
        
            System.out.print("[");
            for (int i = 0; i < arr.length; i++) {
        
                System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
            }
            System.out.println("]");
        }
    
        /** 2、设计一个方法：随机一组中奖号码出来（6个红球号码，1个蓝球号码 ）*/
        public static int[] createLuckNumbers(){
        
            // 创建一个整型数组，用于存储这7个号码
            int[] numbers = new int[7];
            Random r  = new Random();
    
            // 遍历前6个位置处，依次随机一个红球号码存入（1-33 不重复）
            for (int i = 0; i < numbers.length - 1; i++) {
        
                while (true) {
        
                    // 为当前这个位置随机一个红球号码出来存入
                    int number = r.nextInt(33) + 1;
    
                    // 判断这个号码是否之前出现过（红球号码不能重复）
                    if(!exist(numbers, number)){
        
                        numbers[i] = number;
                        break; // 结束死循环，代表找到了当前这个位置的一个不重复的红球号码了
                    }
                }
            }
    
            // 录入一个蓝球号码
            numbers[6] = r.nextInt(16) + 1;
            return numbers;
        }
    
        /** 3、设计一个方法，用于判断用户的中奖情况 */
        public static void judge(int[] userNumbers,int[] luckNumbers){
        
            // 分别定义2个变量用于记住红球命中了几个以及蓝球命中了几个
            int redCount = 0;
            int blueCount;
    
            // 先判断红球命中的数量
            // 遍历用户投注的号码的前6个红球
            for (int i = 0; i < userNumbers.length - 1; i++) {
        
                // 开始遍历中奖号码的前6个红球号码，看用户当前选择的这个号码是否命中了
                for (int j = 0; j < luckNumbers.length - 1; j++) {
        
                    if(userNumbers[i] == luckNumbers[j]){
        
                        redCount++;
                        break;
                    }
                }
            }
    
            // 判断蓝球是否命中了
            blueCount = userNumbers[6] == luckNumbers[6] ? 1 : 0;
    
            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("恭喜您，中奖500万，可以稍微开始享受人生了~~~");
            }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 < 3 && blueCount == 1){
        
                System.out.println("中了5元~");
            }else {
        
                System.out.println("感谢您对福利事业做出的巨大贡献~~~");
            }
        }
    }

**运行结果**

![在这里插入图片描述][cde7e3a2159e4380954e4156006d5921.png]

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[Java]: https://blog.csdn.net/weixin_62511863/category_12365679.html?spm=1001.2014.3001.5482
[f5f933fd20bb47dfa08cc0697b40172a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d19a121171ef465c811e07d893a0f791.png
[6e9fa0c46a3e4e5db427be624ef6aadb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/39f5ff90c96f40c5a53caa2b0fd04e59.png
[3add3b4b23c84edea0a97798fb4230f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/feb4ce230a9249ca9cdc33599ec53063.png
[b18325f0066b4fb7a9f09f747342bf2e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/14afdb61f7194df5a0758c8ede4eafff.png
[f2b82452890d42f78123abc9cdb15a09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/598030c5c3904911bc0a81c9cc4d5f0a.png
[0b1330d934a84c31a528913b28c91316.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a6b3685b0350484f81adb6c35a6a8947.png
[de465bba889949069844e2f05918eb7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/18c6d57c9e0f41478b7ede7ddc91b51d.png
[cde7e3a2159e4380954e4156006d5921.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/6be9e95cd9ca43aa88de530fe42b5bc3.png