《JAVA综合练习01~09》

《JAVA综合练习01~09》

01.买飞机票

• 练习01：买飞机票
• 机票价格按照淡季旺季、头等舱和经济舱收费；
• 输入机票原价、头等舱或经济舱就输出机票购买的价格；
• 按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折；
• 淡季（11月到来年4月）头等舱7折，经济舱6.5折；
• 方法抽取的快捷键 Ctrl + Alt + M

public class Test01 {
    public static void main(String[] args) {
        //1.键盘输入机票原价、月份、经济舱或头等舱
        Scanner s = new Scanner(System.in);
        System.out.println("请输入机票原价：");
        int ticket = s.nextInt();
        System.out.println("请输入当前月份：");
        int month = s.nextInt();
        System.out.println("请选择头等舱或经济舱，头等舱请输入0，经济舱请输入1：");
        int seat = s.nextInt();
        
        //2.调用自定义的ticketPrice1方法
        int ticketPrice1 = ticketPrice(ticket, month, seat);
        System.out.println(ticketPrice1);
    }
    /*
    方法抽取前需要考虑的问题
    1.方法体是什么
    2.方法的参数是什么
    3.方法是否需要返回值，已经返回值类型；
    4.方法抽取的快捷键 Ctrl + Alt + M
     */

    //方法1：判断是淡季还是旺季,返回打折后的机票价格
    public static int ticketPrice(int ticket, int month, int seat) {
        //判断客户输入的当前月份；
        if (month >= 5 && month <= 10) {
            //旺季
            ticket = getTicket(seat, ticket, 0.9, 8.5);
        } else if ((month >= 11 && month <= 12) || (month >= 1 && month <= 4)) {
            //淡季
            ticket = getTicket(seat, ticket, 0.7, 0.65);
        } else {
            //输入错误
            System.out.println("您输入的月份不合法");
        }
        return ticket;
    }

    //方法2：判断头等舱还是经济舱，返回打折后的机票价格
    private static int getTicket(int seat, int ticket, double x, double x1) {
        if (seat == 0) {
            //头等舱
            ticket = (int) (ticket * x);
        } else if (seat == 1) {
            //经济舱
            ticket = (int) (ticket * x1);
        } else {
            System.out.println("没有这个仓位");
        }
        return ticket;
    }
}

02.找质数

• 练习02：判断101~200有多少个质数，并打印所有质数；
• 通过本练习需要掌握嵌套for循环使用、标记位使用、统计变量使用

    public static void main(String[] args) {
        boolean flag = true;//标记位，用于标记当前数字是不是质数
        int count =0;//统计变量，用于统计质数的数量
        for (int i = 101; i <= 200; 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("101~200之间有" + count + "个质数");
    }

03.开发验证码

• 需求：定义方法随机产生一个5位数的验证码；
• 验证码格式：长度为5；前4位是大写字母或者小写字母；最后1位是数字。
• 通过联系掌握26字母的产生方法；字符串拼接方式等；

public class Test03 {
    public static void main(String[] args) {
        //1.获取前4位随机的大写或者小写字母
        //1.1创建一个长度为52的数组，并存a~z 和A~Z 52个字母
        char[] chars = new char[52];
        for (int i = 0; i < 52; i++) {
            if (i <= 25) {
                chars[i] = (char) (97 + i);
            } else {
                chars[i] = (char) (65 + i - 26);
            }
        }
        //1.2使用chars[] 随机产生4个字母，并拼接在一起。
        String result = "";//创建一个空的字符串变量用于拼接结果
        Random r = new Random();//创建一个随机数对象
        for (int i = 0; i < 4; i++) {
            int randomIndex = r.nextInt(chars.length);
            result = result + chars[randomIndex];
        }
        //2.随机产生一个0~9的整数,
        //跟前面生成的4为字母拼接在一起，形成最后结果，并输出。
        int number = r.nextInt(10);
        result = result + number;
        System.out.println(result);
    }
}

04.数组元素的复制

• 本题比较简单，此处略过。。。。。。

05.评委打分

• 题目：在唱歌比赛中，有6名评委给选手打分，分数范围是[0-100]之间的整数。选手的最后得分为:去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。
• 本题难点：获取6个评委打分，并存入数组中的逻辑问题。当评委输入[0-100]之外的分数如何处理。

public class Test04 {
    public static void main(String[] args) {
        //1.获取6个评委的打分
        int[] scores = getScore();
        for (int i = 0; i < scores.length; i++) {
            System.out.println(scores[i]);
        }
        System.out.println("=========");
        //2.找出最大值
        int max = getMax(scores);
        //3.找出最小值
        int min = getMin(scores);
        //4.求出6个评委打分的总和
        int sum = getSum(scores);
        //5.求出最终分数（总和-最大值-最小值）/4
        int finalScore = (sum - max - min) / (scores.length - 2);
        System.out.println(finalScore);
    }

    /**
     * 设计一个方法获取6个评委的打分，存入一个数组中，并返回数组
     * 分析：
     * 1.方法体是什么：去获取评委打分
     * 2.方法需要什么参数：不需要参数，接收键盘输入即可
     * 3.方法需不需要返回值：需要返回存有6个分数的数组
     */
    public static int[] getScore() {
        int[] scores = new int[6];
        Scanner s = new Scanner(System.in);
        for (int i = 0; i < 6; ) {
            System.out.println("请输入您的第" + (i + 1) + "次打分");
            int score = s.nextInt();
            if (score >= 0 && score <= 100) {
                scores[i] = score;
                i++;
            } else {
                System.out.println("您第" + (i + 1) + "次输入的分数不合法！");
            }
        }
        return scores;
    }

    //设计一个方法求数组int[] scores中的最大值
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    //设计一个方法求数组int[] scores中的最小值
    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    //设计一个方法求数组int[] scores的元素之和
    public static int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum;
    }
}

06.整数加密

• 某系统的数字密码大于0，例如1983，采用加密方式进行传输；
• 加密规则如下：每位数加上5；再对10取余；最后将所有数字反转，得到新的加密后的数字；

public class Test05 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入密码：");
        int i1 = s.nextInt();
        int[] arr = getArr(i1);

        //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;
        }

        //4.把数组里的每一个数字进行拼接，变成加密之后的结果；
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i];
        }
        System.out.println();
        System.out.println(number);
    }


    //设计一个方法把一个整数的每一位添加到一个数组中；并返回这个数组；
    public static int[] getArr(int number) {
        //获得一个大约0的整数
        int temp = number;
        //计算数字的长度，为创建数组准备条件；
        int count = 0;
        while (number != 0) {
            number = number / 10;
            count++;
        }
        //创建一个数组
        int[] arr = new int[count];
        //把整数上的每一位添加到数组中
        int index = arr.length - 1;
        while (temp != 0) {
            //获取整数的个位数
            int ge = temp % 10;
            //去掉temp最右边的一位
            temp = temp / 10;
            //把获得的个位添加到数组中
            arr[index] = ge;
            index--;
        }
        return arr;
    }
}

07.整数解密

把上面练习06中加密的整数进行解密

public class Test07 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入需要解密的密码：");
        int number = scanner.nextInt();
        int[] array = getArray(number);

        //1.把的到的数组反转；
        for (int i = 0, j = array.length - 1; i < j; i++, j--) {
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }

        //2.恢复对10取余前数字；
        //如果数组中的数字：在0-4之间就加10，如果在5-9之间则保持不变
        for (int i = 0; i < array.length; i++) {
            if (array[i] >= 0 && array[i] <= 4) {
                array[i] = array[i] + 10;
            }
        }

        //3.数组中的每个数字减5；
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] - 5;
        }

        //4.最后拼接数组中的数字，恢复加密前整数密码
        int orderNumber = 0;
        for (int i = 0; i < array.length; i++) {
            orderNumber = orderNumber * 10 + array[i];
        }
        System.out.println("加密前的整数为：" + orderNumber);
    }

    //设计一个方法把整数密码的每一位存入一个数组中，并返回数组；
    public static int[] getArray(int number) {
        int temp = number;
        //1.获取整数密码的长度
        int count = 0;
        while (number != 0) {
            number = number / 10;
            count++;
        }
        //2.创建长度为count的数组
        int[] array = new int[count];
        //3.把整数密码的每一位提取，并添加到数组中；
        int index = array.length - 1;
        while (temp != 0) {
            //每次循环提取个位，添加到数组中，从后往前添加；
            int i = temp % 10;
            array[index] = i;
            index--;
            //去掉整数密码最后一位；
            temp = temp / 10;
        }
        return array;
    }
}

08.抽奖的两种实现方式

• 题目：
• 一个大V直播抽奖，奖品是现金红包，分别有{2,588,888,1000,10000}五个奖金。
• 请使用代码模拟抽奖打印出每个奖项，奖项的出现顺序要随机且不重复。
• 打印效果如下:(随机顺序，不一定是下面的顺序)
  思路1
• 1.创建一个数组array存放奖金数字{2,588,888,1000,10000}
• 2.创建一个新的数组newArray长度为array.length
• 3.使用for循环在数组array中随机抽取array.length个奖金数字,存入新数组newArray，并且新数组中的元素不能重复；

public class Test08 {
    public static void main(String[] args) {
        //1.创建一个数组array存放奖金数字{2,588,888,1000,10000}
        int[] array = {2, 588, 888, 1000, 10000};

        //2.创建一个新的数组newArray长度为array.length
        int[] newArray = new int[array.length];

        //3.使用for循环在数组array中随机抽取5个奖金数字,存入新数组newArray，并且不能重复；
        Random r = new Random();
        for (int i = 0; i < array.length; ) {
            //3.1在数组array中随机抽取5个奖金数字；
            int randomIndex = r.nextInt(array.length);
            int prize = array[randomIndex];
            //3.2如果新数组中不包含随机到的数字，就数字放入新数组newArray中，如果包含则重新抽取，直到循环结束；
            if (!contains(prize, newArray)) {
                newArray[i] = prize;
                i++;
            }
        }
        for (int i : newArray) {
            System.out.println(i + "元 的奖金被抽出");
        }
    }

    //判断数组中是否存在某个元素
    public static boolean contains(int number, int[] arr) {
        for (int i : arr) {
            if (i == number) {
                return true;
            }
        }
        return false;
    }
}

思路2

• 打乱奖池数组中数字的顺序即可

    public static void main(String[] args) {
        int[] array = {2, 588, 888, 1000, 10000};
        Random r = new Random();
        for (int i = 0; i < array.length; i++) {
            int randomIndex = r.nextInt(array.length);
            int temp = array[i];
            array[i] = array[randomIndex];
            array[randomIndex] = temp;
        }
        for (int i : array) {
            System.out.println(i + "元 的奖金被抽出");
        }
    }

09.双色球系统

• 题目：双色球由6个红球号码和1个蓝色球号码组中；
• 红球号码从1-33个号码中选择，不能重复；
• 蓝色球号码从1-16中选择一个；

第一步：随机抽取一组中奖号码，代码如下：

public class Test10 {
    /**
     * 题目：双色球由6个红球号码和1个蓝色球号码组中
     * 红球号码从1-33个号码中选择，不能重复
     * 蓝色球号码从1-16中选择一个
     */
    public static void main(String[] args) {
        //1.随机生成一组中奖号码
        int[] prizeArray = createNumber();
        for (int i = 0; i < prizeArray.length; i++) {
            System.out.print(prizeArray[i] + " ");
        }
    }

    //生成6个红球、1个蓝色球组成的中奖号码的数组；
    public static int[] createNumber() {
        int[] array = new int[7];
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            int redNumber = r.nextInt(33) + 1;
            if (!contains(redNumber, array)) {
                array[i] = redNumber;
                i++;
            }
        }
        int blueNumber = r.nextInt(16) + 1;
        array[6] = blueNumber;
        return array;
    }

    //判断数组中是否包含某个元素
    public static boolean contains(int number, int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == number) {
                return true;`在这里插入代码片`
            }
        }
        return false;
    }
}

第二步：由用户手动输入一组中奖号码

public class Test10 {
    public static void main(String[] args) {
        //1.用户手动输入一组号码
        int[] userArr = userInputNumber();
		//2.打印用户输入号码
        for (int i = 0; i < userArr.length; i++) {
            System.out.print(userArr[i] + " ");
        }
    }
    
    //让用户手动输入一组中奖号码；
    public static int[] userInputNumber() {
        //1.输入6个红球号码，判断是否合规，如果合规就存入数组中
        int[] array = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第" + (i + 1) + "个红球号码：");
            int redNumber = sc.nextInt();
            //判断用户输入redNumber是否在1-33之间
            if (redNumber>=1 && redNumber<=33){
                //为了保证保证红球不重复，需要判断输入的redNumber在数组array中是否已经存在；
               if (!contains(redNumber,array)){
                   array[i] = redNumber;
                   i++;
               }else {
                   System.out.println("您输入的中奖号码已经存在");
               }
            }else {
                System.out.println("您输入的中奖号码超出范围");
            }
        }

        //2.输入1个蓝球号码，判断是否合规，如果合规就存入数组中
        while (true) {
            System.out.println("请输入1个蓝球号码：");
            int blueNumber = sc.nextInt();
            if (blueNumber>=1 && blueNumber<=16){
                array[array.length-1] = blueNumber;
                break;
            }else {
                System.out.println("您输入的中奖号码超出范围");
            }
        }
        return array;
    }

    //判断数组中是否包含某个元素；
    public static boolean contains(int number, int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == number) {
                return true;
            }
        }
        return false;
    }
}

第三步：最后判断中奖金额

中奖系统全部代码：

public class Test10 {
    /**
     * 题目：双色球由6个红球号码和1个蓝色球号码组中；
     * 红球号码从1-33个号码中选择，不能重复；
     * 蓝色球号码从1-16中选择一个；
     */
    public static void main(String[] args) {
        //1.随机生成一组中奖号码
        int[] prizeArray = createNumber();
        for (int i = 0; i < prizeArray.length; i++) {
            System.out.print(prizeArray[i] + " ");
        }
        System.out.println();
        //2.用户手动输入一组号码
        int[] userArr = userInputNumber();

        for (int i = 0; i < userArr.length; i++) {
            System.out.print(userArr[i] + " ");
        }
        int redCount = 0;
        int blueCount = 0;
        //判断红球的中奖个数；
        for (int i = 0; i < userArr.length - 1; i++) {
            int redNumber = userArr[i];
            for (int j = 0; j < prizeArray.length - 1; j++) {
                if (redNumber == prizeArray[j]) {
                    redCount++;
                    break;
                }
            }
        }
        //判断蓝球的中奖个数；
        int blueNumber = userArr[userArr.length - 1];
        if (blueNumber == prizeArray[prizeArray.length - 1]) {
            blueCount++;
        }
        System.out.println();
        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("谢谢参与");
        }
    }

    //随机生成6个红球、1个蓝色球组成的中奖号码的数组；
    public static int[] createNumber() {
        int[] array = new int[7];
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            int redNumber = r.nextInt(33) + 1;
            if (!contains(redNumber, array)) {
                array[i] = redNumber;
                i++;
            }
        }
        int blueNumber = r.nextInt(16) + 1;
        array[6] = blueNumber;
        return array;
    }

    //判断数组中是否包含某个元素；
    public static boolean contains(int number, int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == number) {
                return true;
            }
        }
        return false;
    }

    //让用户手动输入一组中奖号码；
    public static int[] userInputNumber() {
        //1.输入6个红球号码，判断是否合规，如果合规就存出入数组中
        int[] array = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第" + (i + 1) + "个红球号码：");
            int redNumber = sc.nextInt();
            //判断用户输入redNumber是否在1-33之间
            if (redNumber >= 1 && redNumber <= 33) {
                //为了保证保证红球不重复，需要判断输入的redNumber在数组array中是否已经存在；
                if (!contains(redNumber, array)) {
                    array[i] = redNumber;
                    i++;
                } else {
                    System.out.println("您输入的中奖号码已经存在");
                }
            } else {
                System.out.println("您输入的中奖号码超出范围");
            }
        }

        //2.输入1个蓝球号码，判断是否合规，如果合规就存入数组中
        while (true) {
            System.out.println("请输入1个蓝球号码：");
            int blueNumber = sc.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16) {
                array[array.length - 1] = blueNumber;
                break;
            } else {
                System.out.println("您输入的中奖号码超出范围");
            }
        }
        return array;
    }
}

10.二维数组练习

• 某商城每个季度的营业额如下:单位(万元)
• 第一季度:22,66,44
• 第二季度:77,33,88
• 第三季度:25,45,65
• 第四季度:11,66,99
• 要求计算出每个季度的总营业额和全年的总营业额。

public class Test12 {
    public static void main(String[] args) {
        //1.创建一个二维数组存储每个季度的营业额；
        int[][] arr = {
                {22,66,44},
                {77,33,88},
                {25,45,65},
                {11,66,99}
        };
        int yearSum = 0;
        //2.求每个季度的营业额
        for (int i = 0; i < arr.length; i++) {
            int arrSum = getArrSum(arr[i]);
            System.out.println("第" + (i + 1) + "个季度的营业额为：" + arrSum);
            //3.计算全年的营业额；
            yearSum+=arrSum;
        }
        System.out.println("全年的营业额为：" + yearSum);
    }
    //定义一个数组求和的方法
    public static int getArrSum(int[] arr){
        int sum = 0;
        for (int i : arr) {
            sum+=i;
        }
        return sum;
    }
}