07-综合练习

综合练习

1、卖飞机票

package com.yq.test;
​
import java.util.Scanner;
​
/* idea快捷键拓展：Ctrl + Alt + M
       选中代码块，然后快捷键实现自动抽取方法
*/
​
public class Test1 {
    public static void main(String[] args){
        /*
           需求：
               机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱
               按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折
                                         淡季（11月-来年4月）头等舱7折，经济舱6.5折
        */
​
        // 1.键盘录入机票的原价、月份、头等舱、经济舱
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票原价：");
        int ticket = sc.nextInt();
        System.out.println("请输入当前的月份：");
        int month = sc.nextInt();
        System.out.println("请输入当前购买的舱位 0头等舱 1经济舱：");
        int seat = sc.nextInt();
​
        // 2.判断
        if (month >= 5 && month <= 10){
            //旺季
            ticket = getPrice(ticket, seat, 0.9, 0.85);
        } else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)){
            //淡季
            ticket = getPrice(ticket, seat, 0.7, 0.65);
        } else {
            //录入的月份不合法
            System.out.println("录入的月份不合法");
        }
​
        // 3.输出打折后的价格
        System.out.println(ticket);
    }
​
    // 1.做什么          根据舱位和折扣，计算最终票价
    // 2.需要什么        原价、舱位、头等舱折扣、经济舱折扣
    // 3.是否需要返回值  需要返回值
    public static int getPrice(int ticket, int seat, double v0, double v1){
        if (seat == 0){
            ticket = (int)(ticket * v0);
        } else if (seat == 1){
            ticket = (int)(ticket * v1);
        } else {
            System.out.println("输入的舱位不合法");
        }
        return ticket;
    }
}
​

2、找质数

package com.yq.test;
​
public class Test2{
    public static void main(String[] args){
        // 判断 101~200 之间有多少个质数，并输出所有质数
        
        int count = 0;
        //外循环，遍历101~200,一次得到整个范围内的每个数字
        for (int i = 100; i <= 200; i++){
            boolean flag = true;
            //内循环，判断当前数字 i 是否为一个质数
            for (int j = 2; j < i; j++){
               if (i % j == 0){
                   flag = false;
                   break;  //跳出单层循环，内循环
               }
            }
            if (flag){
                System.out.println("当前数字" + i + "是质数");
                count++;
            }
        }
        System.out.println("一共有 " + count +" 个质数");
    }
​
}

3、开发验证码

package com.yq.test;
​
import java.util.Random;
​
public class Test3{
    public static void main(String[] args){
        /*
     *     需求：定义方法实现随机产生一个5位的验证码
     *     验证码格式：
     *                长度5
     *                前4位是大写字母或者小写字母
     *                最后一位是数字
     * */
​
        // 技巧：将数据存入数组中，利用随机选取索引，来获取随机值
​
        // 1.大小写字母都放入数组中
        char[] chs = new char[52];
        for (int i = 0; i < chs.length; i++){
            //利用ASCLL码表，将字母存入数组中
            if (i < 25){
                //添加小写字母 a --> 97
                chs[i] = (char)(97 + i);
            } else {
                //添加大写字母 A --> 65
                chs[i] = (char)(65 + i - 26);
            }
        }
​
        // 遍历数组
        /* 
        for (int i = 0; i < chs.length; i++){
            System.out.print(chs[i] + " ");
        }
        */
​
        //定义一个字符串类型变量，记录最终结果
        String result = "";
        // 2.随机抽取4次
        Random r = new Random();
        for (int i = 0; i < 4; i++){
            int randomIndex = r.nextInt(chs.length);
            //System.out.println(chs[randomIndex]);
            result = result + chs[randomIndex];
        }
​
        // 3.随机抽取一个数字0-9
        int number = r.nextInt(10);
        result = result + number;
        System.out.println(result);
    }
}

4、数组元素的复制

package com.yq.test;
​
public class Test4{
    public static void main(String[] args){
        // 需求：把一个数组中的元素复制到另一个新数组中去
​
        // 1.定义一个老数组，并存储一些元素
        int[] arr = new int[]{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 < arr.length; i++){
            System.out.println(newArr[i]);
        }
    }
}

5、评委打分

package com.yq.test;
​
import java.awt.desktop.SystemEventListener;
import java.util.Scanner;
​
public class Test5 {
    public static void main(String[] args){
        // 在唱歌比赛中，有6名评委给选手打分，分数范围{0 ~ 100}之间的整数
        // 选手的最后的分位：去掉最高分、最低分后的4个评委的平均分
​
        // 1.用数组存入6个评委的分数
        int[] scoreArr = getScores();
        for (int i = 0; i < scoreArr.length; i++){
            System.out.print(scoreArr[i] + " ");
        }
        System.out.println();
​
        // 2.求最大值
        int max = getMax(scoreArr);
        System.out.println("最高分： " + max);
        
        // 3.求最小值
        int min = getMin(scoreArr);
        System.out.println("最低分： " + min);
​
        // 4.求6个分数的总和
        int sum = getSum(scoreArr);
​
        // 5.(总和 - 最大值 - 最小值) / 4
        int avg = (sum - max - min) / (scoreArr.length - 2);
        System.out.println("选手的最终得分为: " + avg);
    }
​
    // 定义输入分数
    public static int[] getScores(){
        int[] scoreArr = new int[6]; //定义数组
        
        //键盘录入分数 0~100
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scoreArr.length;){
            System.out.println("请输入第" + (i+1) + "个评委的分数: ");
            int score = sc.nextInt();
            if (score >= 0 && score <= 100){
                scoreArr[i] = score;
                i++;
            } else {
                 System.out.println("输入不合法，请重新输入");
            }
        }
        return scoreArr;
    }
​
    // 求数组的最大值
    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;
    }
​
    // 求数组的最小值
    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 getSum(int[] scoreArr){
        int sum = 0;
        for (int i = 0; i < scoreArr.length; i++){
            sum = sum + scoreArr[i];
        }
        return sum;
    }
}
​

6、数字加密

package com.yq.test;
​
import java.util.Scanner;
​
public class Test7 {
    public static void main(String[] args){
        /*
 *          需求：
 *               某系统的数字密码（大于0），比如1983，采用加密方式进行传输
 *               规则：先得到每位数，然后每位数加上5，在对10求余，最后将说有数字反转，得到一串新数
 *      */
​
        // 1.将数字的每位数放入数组中
        //int[] arr = new int[]{1, 9, 8, 3}; //直接定义数组
        
        int numberIn = getIn();  //利用方法将数字导入数组
        int[] arr = getArr(numberIn);
        System.out.println("数字的每位数放入数组中: ");
        printScore(arr);
​
        // 2.加密
        int[] Newarr = getSecret(arr);
​
        // 3.将数组中元素合并为数字
        int number = getResult(Newarr);
        System.out.println("加密后的数字为: " + number);
        
    }
​
    public static int[]  getSecret(int[] arr){
        //每位数加5
        for (int i = 0; i < arr.length; i++){
            arr[i] = arr[i] + 5;
        }
        System.out.println("每位数加5: ");
        printScore(arr);
        
        //每位数对10取余
        for (int i = 0; i < arr.length; i++){
            arr[i] = arr[i] % 10;
        }
        System.out.println("每位数对10取余: ");
        printScore(arr);
​
        //反转数字
        for (int i = 0, j = arr.length - 1; i < j; i++, j--){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        System.out.println("反转数字: ");
        printScore(arr);
​
        return arr;
    }        
    
    //遍历数组每个元素
    public static void printScore(int[] arr){
        System.out.print("    ");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
​
    //数组转为数字
    public static int getResult(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++){
            sum = sum * 10 + arr[i];
        }
        return sum;
    }
​
    //数字转为数组
    public static int[] getArr(int number){
        //利用循环，计算数组的长度
        int count = 1;
        int result = number;
        while (result > 10){
            result = result / 10;
            count++;
        }
​
        //定义数组
        int[] arr = new int[count];
​
        //将每一位数字，添加到数组中
        for (int i = count - 1; i >= 0; i--){
            arr[i] = number % 10; //获取个位的值
            number = number / 10; //去掉各位的数字
        }
        return arr;
    }
​
    //键盘录入数字
    public static int getIn(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个大于0的数字: ");
        int n = sc.nextInt();
        return n;
    }
}
​

7、数字解密

package com.yq.test;
​
import java.util.Scanner;
​
public class Test8 {
    public static void main(String[] args){
        /*
 *          需求：
 *               某系统的数字密码（大于0），比如1983，采用加密方式进行传输
 *               规则：先得到每位数，然后每位数加上5，在对10求余，最后将说有数字反转，得到一串新数
 *               对上面的加密规则进行解密
 *      */
​
        // 1.将数字的每位数放入数组中
        //int[] arr = new int[]{1, 9, 8, 3}; //直接定义数组
        
        int numberIn = getIn();  //利用方法将数字导入数组
        int[] arr = getArr(numberIn);
        System.out.println("数字的每位数放入数组中: ");
        printScore(arr);
​
        // 2.加密
        int[] Newarr = getSecret(arr);
​
        // 3.将数组中元素合并为数字
        int number = getResult(Newarr);
        System.out.println("解密后的数字为: " + number);
        
    }
​
    //解密方法
    public static int[]  getSecret(int[] arr){
        //反转数字
        for (int i = 0, j = arr.length - 1; i < j; i++, j--){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        System.out.println("反转数字: ");
        printScore(arr);
​
        //解密每位数对10取余。由于加密是对10取余，解密需要进行判断 0~4之间+10，5~9数字不变
        /* 实现原理
 *        给定数字放入数组后，数组中每个数据的取值可能只有 0 1 2 3 4 5 6 7 8 9
 *        加密过程：
 *                  1.加5 ：    5  6  7  8  9  10  11  12  13  14
 *                  2.对10取余：5  6  7  8  9  0   1   2   3   4
 *        解密过程：
 *                 5  6  7  8  9  0   1   2   3   4
 *                                ||  
 *                                \/
 *                 5  6  7  8  9  10  11  12  13  14
 *                 不难看出: (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;
            }
        }
        System.out.println("每位数对10取余的解密: ");
        printScore(arr);
​
        //每位数减5
        for (int i = 0; i < arr.length; i++){
            arr[i] = arr[i] - 5;
        }
        System.out.println("每位数减5: ");
        printScore(arr);
​
        return arr;
    }        
    
    //遍历数组每个元素
    public static void printScore(int[] arr){
        System.out.print("    ");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
​
    //数组转为数字
    public static int getResult(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++){
            sum = sum * 10 + arr[i];
        }
        return sum;
    }
​
    //数字转为数组
    public static int[] getArr(int number){
        //利用循环，计算数组的长度
        int count = 1;
        int result = number;
        while (result > 10){
            result = result / 10;
            count++;
        }
​
        //定义数组
        int[] arr = new int[count];
​
        //将每一位数字，添加到数组中
        for (int i = count - 1; i >= 0; i--){
            arr[i] = number % 10; //获取个位的值
            number = number / 10; //去掉各位的数字
        }
        return arr;
    }
​
    //键盘录入数字
    public static int getIn(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个大于0的数字: ");
        int n = sc.nextInt();
        return n;
    }
}

8、抽奖

8.1 抽奖初级算法

public class Test9{
    public static void main(String[] args){
       /*
 *        需求：抽奖，奖品为现金红包，分别有 {2, 588, 888, 1000, 10000} 五个奖金
 *              用代码模拟抽奖，打印出每个奖项，奖项的出现顺序随机且不重复
 *              效果类似如下（随机顺序，不一定是下面的顺序）
 *                  888元的奖金被抽出
 *                  588元的奖金被抽出
 *                  10000元的奖金被抽出
 *                  1000元的奖金被抽出
 *                  2元的奖金被抽出
 * */
​
        //1.定义数组表示奖池
        int[] arr = new int[]{2, 588, 888, 1000, 10000};
​
        //2.定义新数组用于存储抽奖的结果
        int[] newArr = new int[arr.length];
​
        //3.抽奖
        Random r = new Random();
        for (int i = 0; i < 5;){
            //获取随机索引
            int randomIndex = r.nextInt(arr.length);
            //获取奖项
            int prize = arr[randomIndex];
            //判断当前奖项是否存在
            boolean falg = contains(newArr, prize);
            if (!falg){
                newArr[i] = prize; //如果判断结果为true，则将奖项添加到newArr中
                i++; //添加完后，移动索引
            }
        }
​
        //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;
    }
}

8.2 抽奖算法优化

public class Test10{
    public static void main(String[] args){
       /*
 *        需求：抽奖，奖品为现金红包，分别有 {2, 588, 888, 1000, 10000} 五个奖金
 *              用代码模拟抽奖，打印出每个奖项，奖项的出现顺序随机且不重复
 *              效果类似如下（随机顺序，不一定是下面的顺序）
 *                  888元的奖金被抽出
 *                  588元的奖金被抽出
 *                  10000元的奖金被抽出
 *                  1000元的奖金被抽出
 *                  2元的奖金被抽出
 * */

        //1.定义数组表示奖池
        int[] arr = new int[]{2, 588, 888, 1000, 10000};

        //2.将奖池中的所有奖项打乱顺序
        Random r = new Random();
        for (int i = 0; i < arr.length; i++){
            //获取随机索引
            int randomIndex = r.nextInt(arr.length);
            
            //利用索引，将数组中两个数据进行交换
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }

        //3.遍历奖池
        for (int i = 0; i < arr.length; i++){
            System.out.println(arr[i] + "元的奖金被抽出");
        }
    }
}

9、模拟双色球抽奖

package com.yq.test;

import java.util.Scanner;
import java.util.Random;

public class Test11{
    public static void main(String[] args){
        // 1.利用方法生成中奖号码
        int[] arr = createNumber();
        // 遍历中奖号码
        System.out.println("提示：中奖号码如下");
        printArr(arr);

        // 2.用户输入彩票号码（红球 + 篮球）
        int[] userInputArr = userInputNumber();
        // 遍历中奖号码
        printArr(userInputArr);

        // 3.判断用户的中奖情况
        int redCount = 0;
        int blueCount = 0;
        /*
 *         方法1：对用户输入的红球号码，每一个进行循环遍历，每一个都检查一遍是否在6个红球中奖号码中
        for (int i = 0; i < userInputArr.length - 1; i++){
            int redNumber = userInputArr[i];
            for (int j = 0; j < arr.length - 1; j++){
                if (redNumber == arr[j]){
                    redCount++;
                    break;
                }
            }
        }
 */
        
        /*
        // 方法2：调用写好的方法 contains ，先生成中奖号码中只有红色球的数组，在利用contains方法进行判断
 */
        for (int i = 0; i < userInputArr.length - 1; i++){
            int[] arrRed = new int[arr.length - 1];
            for (int j = 0; j < arrRed.length; j++){
                arrRed[j] = arr[j];
            }
            boolean flag = contains(arrRed,userInputArr[i]);
            if (flag){
                redCount++;
            }
        }

        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("恭喜你，中奖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 == 2 && blueCount == 1) || (redCount == 1 && blueCount == 1) || (redCount == 0 && blueCount == 1)){
            System.out.println("恭喜你，中奖5元");
        } else {
            System.out.println("很抱歉，你没有中奖");
        }
    }

    public static void printArr(int[] arr){
        // 遍历数组中所有数字
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static int[] userInputNumber(){
        // 1.创建数组用于添加用户购买的彩票号码
        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();
            if (redNumber >= 1 && redNumber <= 33){
                boolean flag = contains(arr, redNumber);
                if (!flag){
                    arr[i] = redNumber;
                    i++;
                }
            } else {
                System.out.println("当前红球号码超出范围");
            }
        }

        //让用户输入篮球号码
        System.out.println("请输入篮球号码: ");
        while (true){
            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.创建数组用于添加中奖号码
        int[] arr = new int[7];

        // 2.随机生成号码并添加到数组中
        // 红球：不能重复 1 2 3 4 5 6 
        // 篮球：可以跟红球号码重复 5
        
        // 生成红球号码，并添加到数组中
        Random r = new Random();
        for  (int i = 0; i < arr.length - 1;){
            int redNumber = r.nextInt(33) + 1;
            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;
    }
}

10、二维数组

当我们需要将数据分组管理时，则需要用到二维数组

二维数组静态初始化

/*
    静态初始化：
         格式：数据类型[][] 数组名 = new 数据类型[][] { {}, {}};
         范例：int[][] arr = new int[][]{ {11, 22}, {33, 44}};
         简化格式：数据类型[][] 数组名 = { {}, {}};
         范例：int[][] arr = { {11, 22}, {33, 44}};

*/
public class TwoDimensionDemo1 {
    public static void main(String[] args){
        /*
        *    二维数组静态初始化格式：
        *                 数据类型[][] 数组名 = new 数据类型[][] { {元素1,元素2}, {元素1,元素2} };
        *    简化格式：
        *                 数据类型[][] 数组名 = {元素1,元素2}, {元素1,元素2} };
        *    元素访问：
        *                 数组名[索引][索引];
        *    二维数组遍历:
        *                 先得到一维数组，再遍历一维数组获取元素
        */

        // 1.二维数组静态初始化
        int[][] arr1 = new int[][]{ {1, 2, 3}, {4, 5, 6, 7, 8} };
        int[][] arr2 = { {1, 2, 3}, {4, 5, 6, 7, 8} };

        //注意：每一个一维数组其实是二维数组中的元素，建议以后按照arr3写二维数组
        int[][] arr3 = {
                {1, 2, 3},
                {4, 5, 6, 7, 8}
        };

        // 2.获取元素
        // arr[i][j]
        // arr: 二维数组
        // i: 二维数组的索引，获取到里面的一维数组
        // j: 一维数组中的索引，获取到真正的元素
        System.out.println(arr3[0]); // 获取二维数组中，第一个一维数组的地址值

        //获取二维数组中，第一个一维数组的0索引的元素
        System.out.println(arr3[0][0]); // 1
        System.out.println(arr3[1][4]); // 8
        // System.out.println(arr3[2][0]); // 执行后会报错，ArrayIndexOutOfBoundsException

        System.out.println("=============================");
        
        // 3.遍历二维数组
        // 外循环：遍历二维数组，得到里面的每一个一维数组
        for (int i = 0; i < arr3.length; i++){
            // 内循环：遍历一维数组的每一个索引
            for (int j = 0; j < arr3[i].length; j++){
                System.out.print(arr3[i][j] + " ");
            }
            System.out.println();
        }
    }
}

二维数组动态初始化

public class TwoDimensionDemo2{
    public static void main(String[] args){
        /*
           二维数组动态初始化格式：
               数据类型[][] 数组名 = new 数据类型[m][n];
               m表示这个二维数组，可以存放多少个一维数组
               n表示每个一维数组，可以存放多少个元素
        */

        // 1.创建二维数组
        int[][] arr = new int[3][5];  // 可以存3个一维数组，每个一维数组可存5个元素
        //赋值一个元素
        arr[0][0] = 10;
        //遍历
        for (int i = 0; i < arr.length; i++){
            for (int j = 0; j < arr[i].length; j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

二维数组的内存图

(一维数组在堆空间中存索引地址值，索引地址值指向具体存数据的元素)

(二维数组在堆空间中存一维数组索引地址值，索引地址值指向一维数组索引地址值，一维数组索引值中再指向存数据的元素)

二维数组的特殊情况

// 特殊情况一（创建二维数组，定义其中的一维数组的地址值为 null）
public static void main(String[] args){
    int[][] arr = new int[2][];
    int[] arr1 = {11, 22};
    int[] arr2 = {44, 55, 66};

    arr[0] = arr1;
    arr[1] = arr2;
}

// 特殊情况二 （创建二维数组，定义其中的一维数组的地址值为 每个一维数组(元素值都为0)的地址值）
public static void main(String[] args){
    int[][] arr = new int[2][3];
    int[] arr1 = {11, 22};
    int[] arr2 = {44, 55, 66};

    arr[0] = arr1;
    arr[1] = arr2;
}