Java世纪难题

最新推荐文章于 2024-08-24 17:09:16 发布

Alacan

最新推荐文章于 2024-08-24 17:09:16 发布

阅读量1k

点赞数 24

文章标签： java 开发语言

本文链接：https://blog.csdn.net/Alacan/article/details/139987582

版权

专题课集合阶段

目的：

复习前半段课程学的Java编程知识能够使用所学的知识解决问题提升能力

涉及知识点：

！变量数组

！！运算符：基本运算符关系运算符逻辑运算符……

！！！程序流程控制： if switch for while 死循环循环嵌套

！V 跳转关键字 break continue return

V 方法

VI 键盘录入随机数

@ 1 卖飞机票

需求：

机票价格按照淡季旺季、头等舱经济舱收费、输入机票原价、月份和头等舱或经济舱

按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折

分析

键盘录入需要录入机票原价月份头等舱或经济舱

先判断月份是淡季还是旺季

继续判断是经济舱还是头等舱

根据实际情况计算出相应价格

表示录入非法月份

代码：

package com.exception.demo02;

import java.util.Scanner;

public class Demo13 {
    public static void main(String[] args) {
        /*
        机票价格按照淡季旺季、头等舱经济舱收费、输入机票原价、月份和头等舱或经济舱
        按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，
        淡季（11月到来年4月）头等舱7折，经济舱6.5折
         */
        //键盘录入
        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();

        //判断旺季还是淡季
        if (month >= 5 && month <= 10){
            //旺季
            if (seat == 0) {
                ticket = (int)(ticket * 0.9);
            }else if (seat == 1){
                ticket = (int)(ticket * 0.85);
            }else{
                System.out.println("没有这个舱位");
            }
        }else if (month >= 1 && month <= 4 || month >= 11 && month <= 12){
             //淡季
            if (seat == 0){
                ticket = (int)(ticket * 0.7);
            }else if(seat == 1){
                ticket = (int)(ticket * 0.65);
            }else{
                System.out.println("没有这个舱位");
            }
        }else{
            System.out.println("键盘录入月份不合法");
        }

        System.out.println(ticket);
    }

}

优化代码：

package com.exception.demo02;

import java.util.Scanner;

public class Demo13 {
    public static void main(String[] args) {
        /*
        机票价格按照淡季旺季、头等舱经济舱收费、输入机票原价、月份和头等舱或经济舱
        按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，
        淡季（11月到来年4月）头等舱7折，经济舱6.5折
         */
        //键盘录入
        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();

        //判断旺季还是淡季
        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("键盘录入月份不合法");
        }

        System.out.println(ticket);
    }
    
    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;
    }

}

抽取代码快捷键：ctrl alt+m

package com.exception.demo02;

import java.util.Scanner;

public class Demo13 {
    public static void main(String[] args) {
        /*
        机票价格按照淡季旺季、头等舱经济舱收费、输入机票原价、月份和头等舱或经济舱
        按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，
        淡季（11月到来年4月）头等舱7折，经济舱6.5折
         */
        //键盘录入
        //根据1代码抽取这一部分
        /* if (seat == 0) {
                ticket = (int)(ticket * 0.9);
            }else if (seat == 1){
                ticket = (int)(ticket * 0.85);
            }else{
                System.out.println("没有这个舱位");
            }
        */
        //抽取完之后系统会进行优化
        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();
        
        //判断旺季还是淡季
        if (month >= 5 && month <= 10){
            //旺季
            ticket = getTicket(ticket, seat, 0.9, 0.85);
        }else if (month >= 1 && month <= 4 || month >= 11 && month <= 12){
             //淡季
            ticket = getTicket(ticket, seat, 0.7, 0.65);
        }else{
            System.out.println("键盘录入月份不合法");
        }

        System.out.println(ticket);
    }

    private static int getTicket(int ticket, int seat, double v, double v2) {
        if (seat == 0) {
            ticket = (int) (ticket * v);
        } else if (seat == 1) {
            ticket = (int) (ticket * v2);
        } else {
            System.out.println("没有这个舱位");
        }
        return ticket;
    }

}

@ 2 找质数编程题

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

（素数和质数是一回事）

思路：

判断101-200之间有多少个素数并打印

代码：

package com.exception.demo02;

public class Demo12 {
    public static void main(String[] args) {

        int count = 0;
        for (int i = 101; i <= 200 ; i++) {

            boolean flag = true;
            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 开发验证码

需求：

定义方法实现随机产生一个 5 位的验证码

验证码格式：

长度为 5

前四位是大写字母或者小写字母

最后一位是数字

代码：

package com.exception.demo02;

import java.util.Random;

public class Demo11 {
    public static void main(String[] args) {
        //分析：
        //1.大写字母和小写字母都放到数组当中

        char[] chs = new char[52];
        for (int i = 0; i < chs.length; i++) {
            //ASCII表
            if (i <= 25){
                //添加小写字母 强转
                chs[i] = (char)(97 + i);
            }else{
                //添加大写字母
                //A-----65
                chs[i]=(char)(65 + i - 26);
            }
        }
        //定义一个字符串类型的变量 用来记录最终结果
        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];
        }
        //System.out.println(result);
        //3 随机抽取一个数字0-9
        int number = r.nextInt(10);
        //生成最终结果

        result = result + number;

        //打印最终结果
        System.out.println(result);
    }
}

@ 4 数组元素的复制

需求：

把一个数组中的元素复制到另一个新数组中去

代码：

package com.exception.demo02;

public class Demo10 {
    public static void main(String[] args) {

        //分析 定义一个老数组存储一些元素
        int[] arr = {1,2,3,4,5};

        //定义一个新数组长度和老数组一样
        int[] newArr = new int[arr.length];

        //遍历老数组 得到老数组中的每一个元素 依次存入新数组中
        for (int i = 0; i < arr.length; i++) {
            //i表示老数组中的索引 新数组中的每一个索引
            //arr[i] 表示老数组中的元素
            newArr[i] = arr[i];
        }
        //新数组中已经存满元素了
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]);
        }
    }
}

@ 5 评委打分

需求：

在唱歌比赛中有 6 名评委给选手打分分数范围是[0-100]之间的整数

选手最后的得分为去掉最高分最低分后的4个评委的平均分请完成上述过程并计算选手的得分

代码

package com.exception.demo02;

import java.util.Scanner;

public class Demo09 {
    public static void main(String[] args) {
        //分析定义一个数组 用来存储6为评委打分
        int[] scoreArr = getScores();
        for (int i = 0; i < scoreArr.length; i++) {
            System.out.println(scoreArr[i]);
        }
        //求出数组最大值
        int max = getMax(scoreArr);
        //求出数组最小值
        int min = getMin(scoreArr);
        //求出6个分数总和
        int sum = getSum(scoreArr);
        //（总和 最大值 最小值）
        int avg = (sum - max - min)/(scoreArr.length - 2);
        //打印结果
        System.out.println("选手最终得分为："+avg);
    }
    public static int getSum(int[] scoreArr){
        int sum = 0;
        for (int i = 0; i < scoreArr.length; i++) {
            sum = sum + scoreArr[i];
        }
        return sum;
    }

    public static int getMax(int[] scoreArr){
        int max = scoreArr[0];
        for (int i = 0; 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 = 0; i < scoreArr.length; i++) {
            if (scoreArr[i] < min){
                min = scoreArr[i];
            }
        }
        return min;
    }

    public static int[] getScores(){

        int[] scores = new int[6];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入评委打分");
            int score = sc.nextInt();
            if (score >= 0 && score <= 100){
                scores[i] = score;
            }else{
                System.out.println("程序超出了范围，继续录入，当前i为:"+i);
            }

        }
        return scores;
    }
}

@ 6 数字加密

需求：

某系统的数字密码（大于 0 ）比如1983 采用加密方式进行传输

规则如下：

先得到每位数然后每位数都加上5 再对10求余最后将所有数字反转

得到一串新数

代码

package com.exception.demo02;

public class Demo08 {
    public static void main(String[] args) {

        //分析 把整数里面的每一位放到数组当中
         int[] arr = {1,9,3,8};

         //加密
        //每一个数字加上5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] + 5;
        }
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] % 10;
        }
        for (int i = 0,j = arr.length-1; i < j; i++,j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + " ");
        }
        //把数组中里面的每一个数字进行拼接 变成加密后的结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 +arr[i];
        }
        System.out.println(number);
    }
}

优化代码：

package com.exception.demo02;

public class Demo07 {
    public static void main(String[] args) {

        //计算数组的长度
        int number = 12345;

        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){
            //获取temp里面每一位数组
            int ge = temp % 10;
            temp = temp / 10;
            //把当前获取的个位数添加到数组中
            arr[index] = ge;
            index--;
        }
        //验证结果
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

@ 7 数字解密

需求：

某系统的数字密码（大于0）比如1983 采用加密方式进行传输

规则如下：

每位数字加上5 再对10求余最后将所有数字反转得到一串新数

按照以上规则进行解密

比如 1983 加密后变成 8346 解密后变成 1983

代码

package com.exception.demo02;

public class Demo06 {
    public static void main(String[] args) {
        //定义数组记录后解密之后结果
        int[] arr = {8,3,4,6};

        //反转
        for (int i = 0,j = arr.length-1; i < j; i++,j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //由于加密通过对10取余的方式获取
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] >= 0 && arr[i] <=4){
                arr[i] = arr[i] + 10;
            }
        }
        //每一位减5
        for (int i = 0; i < arr.length; i++) {
           arr[i] = arr[i] - 5;
        }
        //获取数组里面每一位数字拼接成最终结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i];
        }
        System.out.println(number);
    }
}

@ 8 抢红包

需求：

一个大v直播抽奖奖品是现金红包分别有{2，588，888，1000，10000}五个奖金请使用代码模拟抽奖打印出每个奖项奖项的出现顺序要随机且不能重复

打印效果：（随机顺序不一定是一样的顺序）

代码：

package com.exception.demo02;

import java.util.Random;

public class Demo05 {
    public static void main(String[] args) {
        //1定义数组奖池
        int[] arr = {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 flag = contains(newArr, prize);
            if (!flag) {
                //把当前抽取到的奖项添加到newArr中
                newArr[i] = prize;
                //添加完毕之后，移动索引
                i++;
            }
        }


        //4遍历数组
        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;
    }

}

代码 2

package com.exception.demo02;

import java.util.Random;

public class Demo04 {
    public static void main(String[] args) {
        //把奖池里的所有奖项打乱
        int[] arr = {2, 588, 888, 1000, 10000};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //获取随机索引
            int randomIndex = r.nextInt(arr.length);

            //拿着i跟随机索引randomIndex交换值
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
        //2遍历奖池 从0开始取每一个奖项
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);

        }
    }
}

@ 9 双色球系统

投注号码由6个红色球号码和1个蓝色球号码组成

红色球号码从1-33中选择蓝色球号码从1-16中选择

双色球中奖条件和奖金表

一等奖 6个红球 1个蓝球中6+1 最高1000万

二等奖 6个红球中6+0 最高500万

三等奖 5个红球 1个蓝球中5+1 3000元

四等奖 5个红球中5+0 200元

4个红球 1个蓝球中4+1 200元

五等奖 4个红球中4+0 10元

3个红球 1个蓝球中3+1 10元

2个红球 1个蓝球中2+1 10元

六等奖 1个红球 1个蓝球中1+1 5元

1个蓝球中0+1 5元

生成一个中奖号码代码：

package com.exception.demo02;

import java.util.Random;

public class Demo03 {
    public static void main(String[] args) {
        //生成中奖号码
        int[] arr = createNumber();

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
    public static int[] createNumber(){
        //1创建数组用于中奖号码
        //6个红球 1个蓝球   数组长度7
        int[] arr = new int[7];

        //随机生成号码并添加到数组当中
        //红球：不能重复的 1 2 3 4 5 6
        //蓝球：可以跟红球重复号码 5

        //生成红色号码并添加到数组当中
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            //获取红球号码
            int redNumber = r.nextInt(33)+1;
            boolean flag = contains(arr,redNumber);
            if (!flag){
                //把红球号码添加到数组当中
                arr[i] =redNumber;
                i++;
            }
        }
        //生成蓝球号码并添加到数组当中
        int blurNumber = r.nextInt(16)+1;
        arr[arr.length-1] = blurNumber;

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

让用户去输入一个中奖号码代码：

package com.exception.demo02;

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

public class Demo02 {
        public static void main(String[] args) {
            //生成中奖号码
            int[] arr = createNumber();

            //用户输入彩票号码（红球 + 蓝球）
            int[] userInputArr = userInputNumber();
            for (int i = 0; i < userInputArr.length; i++) {
                System.out.print(userInputArr[i] + " ");
            }

        }
        public static int[] userInputNumber(){
            //创建数组用于添加用户购买的彩票号码
            //个红球 1个蓝球   数组长度7
            int[] arr = 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){
                    boolean flag = contains(arr,redNumber);
                    if (!flag){
                        //不存在 有效的 可以添加到数组当中
                        arr[i] = redNumber;
                        i++;
                    }else{
                        //存在
                        System.out.println("当前红球号码已经存在，请重新输入");
                    }
                }else{
                    System.out.println("当前红球号码超出范围");
                }

            }

            //让用户请输入蓝球号码
            System.out.println("请输入蓝球号码");

            //1-16   ctrl + alt + t  选while包裹
            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创建数组用于中奖号码
            //6个红球 1个蓝球   数组长度7
            int[] arr = new int[7];

            //随机生成号码并添加到数组当中
            //红球：不能重复的 1 2 3 4 5 6
            //蓝球：可以跟红球重复号码 5

            //生成红色号码并添加到数组当中
            Random r = new Random();
            for (int i = 0; i < 6; ) {
                //获取红球号码
                int redNumber = r.nextInt(33)+1;
                boolean flag = contains(arr,redNumber);
                if (!flag){
                    //把红球号码添加到数组当中
                    arr[i] =redNumber;
                    i++;
                }
            }
            //生成蓝球号码并添加到数组当中
            int blurNumber = r.nextInt(16)+1;
            arr[arr.length-1] = blurNumber;

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


}

进行奖项校验代码：

package com.exception.demo02;

import java.util.Random;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //生成中奖号码
        int[] arr = createNumber();

        System.out.println("====================================");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println("====================================");

        //用户输入彩票号码（红球 + 蓝球）
        int[] userInputArr = userInputNumber();

        //判断用户的中奖情况
        //红球 蓝球
        int redCount = 0;
        int blueCount = 0;

        //判断红球
        for (int i = 0; i < userInputArr.length-1; i++) {
            int redNumber = userInputArr[i];
            for (int j = 0; j < arr.length; j++) {
                if(redNumber == arr[j]){
                    redCount++;
                    //跳出内循环判断红球是否中奖
                    break;
                }
            }

        }
        //判断蓝球
        int blueNumber = userInputArr[userInputArr.length-1];
        if (blueNumber == arr[arr.length-1]){
            blueCount++;
        }
        System.out.println(redCount);
        System.out.println(blueCount);

    }
    public static int[] userInputNumber(){
        //创建数组用于添加用户购买的彩票号码
        //个红球 1个蓝球   数组长度7
        int[] arr = 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){
                boolean flag = contains(arr,redNumber);
                if (!flag){
                    //不存在 有效的 可以添加到数组当中
                    arr[i] = redNumber;
                    i++;
                }else{
                    //存在
                    System.out.println("当前红球号码已经存在，请重新输入");
                }
            }else{
                System.out.println("当前红球号码超出范围");
            }

        }

        //让用户请输入蓝球号码
        System.out.println("请输入蓝球号码");

        //1-16   ctrl + alt + t  选while包裹
        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创建数组用于中奖号码
        //6个红球 1个蓝球   数组长度7
        int[] arr = new int[7];

        //随机生成号码并添加到数组当中
        //红球：不能重复的 1 2 3 4 5 6
        //蓝球：可以跟红球重复号码 5

        //生成红色号码并添加到数组当中
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            //获取红球号码
            int redNumber = r.nextInt(33)+1;
            boolean flag = contains(arr,redNumber);
            if (!flag){
                //把红球号码添加到数组当中
                arr[i] =redNumber;
                i++;
            }
        }
        //生成蓝球号码并添加到数组当中
        int blurNumber = r.nextInt(16)+1;
        arr[arr.length-1] = blurNumber;

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

生成中奖奖项

package com.exception.demo02;

import java.util.Random;

import java.util.Scanner;
import java.util.jar.JarOutputStream;

public class Demo01 {
    public static void main(String[] args) {
        //生成中奖号码
        int[] arr = createNumber();

        System.out.println("====================================");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println("====================================");

        //用户输入彩票号码（红球 + 蓝球）
        int[] userInputArr = userInputNumber();

        //判断用户的中奖情况
        //红球 蓝球
        int redCount = 0;
        int blueCount = 0;

        //判断红球
        for (int i = 0; i < userInputArr.length-1; i++) {
            int redNumber = userInputArr[i];
            for (int j = 0; j < arr.length; j++) {
                if(redNumber == arr[j]){
                    redCount++;
                    //跳出内循环判断红球是否中奖
                    break;
                }
            }

        }
        //判断蓝球
        int blueNumber = userInputArr[userInputArr.length-1];
        if (blueNumber == arr[arr.length-1]){
            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 int[] userInputNumber(){
        //创建数组用于添加用户购买的彩票号码
        //个红球 1个蓝球   数组长度7
        int[] arr = 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){
                boolean flag = contains(arr,redNumber);
                if (!flag){
                    //不存在 有效的 可以添加到数组当中
                    arr[i] = redNumber;
                    i++;
                }else{
                    //存在
                    System.out.println("当前红球号码已经存在，请重新输入");
                }
            }else{
                System.out.println("当前红球号码超出范围");
            }

        }

        //让用户请输入蓝球号码
        System.out.println("请输入蓝球号码");

        //1-16   ctrl + alt + t  选while包裹
        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创建数组用于中奖号码
        //6个红球 1个蓝球   数组长度7
        int[] arr = new int[7];

        //随机生成号码并添加到数组当中
        //红球：不能重复的 1 2 3 4 5 6
        //蓝球：可以跟红球重复号码 5

        //生成红色号码并添加到数组当中
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            //获取红球号码
            int redNumber = r.nextInt(33)+1;
            boolean flag = contains(arr,redNumber);
            if (!flag){
                //把红球号码添加到数组当中
                arr[i] =redNumber;
                i++;
            }
        }
        //生成蓝球号码并添加到数组当中
        int blurNumber = r.nextInt(16)+1;
        arr[arr.length-1] = blurNumber;

        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 二维数组

什么是二维数组？

数组中存数组二维数组

二维数组应用场景

把数据分组管理用到二维数组

某商城每个季度营业额如下：单位（万元）

第一季度： 22 ， 66 ，44

第二季度： 77 ， 33 ，88

第三季度： 25 ， 45 ，65

第四季度： 11 ， 66 ，99

要求计算出每个季度总营业额和全年的总营业额

代码

package com.exception.demo02;

public class Test16 {
    public static void main(String[] args) {

        //创建二维数组并存储数据
        int[][] yearArrArr = {
                {22,66,44},
                {77,33,88},
                {25,45,65},
                {11,66,99}
        };
        //表示全年营业额
        int yearSum = 0;
        //遍历二维数组 得到每一个一维数组并求和
        for (int i = 0; i < yearArrArr.length; i++) {
            //i 二维数组中的每一个索引
            //yearArrArr[i]元素（一维数组）

            int[] quarterArr = yearArrArr[i];
            int sum = getSum(quarterArr);
            System.out.println("第"+(i+1)+"个季度的总营业额为:"+sum);
            yearSum = yearSum + sum;
        }
        System.out.println("全年的总营业额为:"+yearSum);

    }
    //定义一个方法 计算每一个季度的营业额
    public static int getSum(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum;
    }
}