Java综合练习

需求1：机票价格按照淡季旺季、头等舱和经济舱收费；输入机票原价、月份和头等舱或经济舱。
按照如下规则计算机票价格：旺季(5-10月)头等舱9折，经济舱8.5折，淡季(11月到来年4月)头等舱7折，经济舱6.5折。

（关于这道题的代码，没有什么难度，只是对if语句不熟练，复习一下就回忆起来了，不是重点）

代码如下：

import java.util.Scanner;

public class TestDemo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入机票的价格：");
        int ticket = scanner.nextInt();
        System.out.println("请输入当前的月份：");
        int month = scanner.nextInt();
        System.out.println("请机票的舱位：0 经济舱；1 头等舱");
        int seat = scanner.nextInt();
        System.out.println(price(ticket,month,seat));
    }
    static int price(int ticket,int month,int seat){
       if(month >= 5 && month <= 10){
           //旺季
           ticket = getTicket(seat, ticket, 0.85, 0.9);

       } else if((month >= 1 && month <= 4)  || (month >= 11 && month <= 12)) {
           //淡季
           ticket = getTicket(seat, ticket, 0.65, 0.7);
       }
       return ticket;
    }

    private static int getTicket(int seat, int ticket, double x, double x1) {
        if (seat == 0) {
            ticket = (int) (ticket * x);
        }
        if (seat == 1) {
            ticket = (int) (ticket * x1);
        }
        return ticket;
    }
}

回忆以前的知识点。

一、如何键盘录入？

1、创建一个Scanner对象；

2、然后通过对象调用nextInt()方法。

二、分支语句

（1）if语句

1、第一种格式：只有一个条件，只关注满足条件时要做什么。

if(条件表达式){
    语句体；
}

注意点：

如果语句体只有一行代码，则if后面的大括号可以省略，但是不建议这样做。

2、第二种格式：只有一个条件，关注两点，即满足条件和不满足条件时各自要做什么！

if(条件表达式){
    语句体;
}
else{
    语句体;
}

3、第三种格式：多条件判断，一般是判断一个值属于众多条件表达式中的哪一个。关注满足条件时要做什么，不满足条件时进入到下一个条件的判断。

if(条件表达式1){
    语句体1;
}
else if(条件表达式2){
    语句体2;
}
...

自己总结就是，else的后面可以是第一种格式，也可以是第二种格式。

（2）switch语句

多条件判断时用if语句很麻烦，这里就出现了switch。

基本格式：

switch(条件表达式){
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
        ...
    default:
        语句体n;
        break;
}

有一个疑问就是case后面的语句体要用大括号括起来吗？

1、关于default的位置以及default是否可以省略？

关于default的位置：default也可以放在case语句的前面，放在哪里都可以，不一定要放在最后的位置。

关于default是否可以省略：答案是可以，语法没有错误，但是当switch中条件表达式的值与case中的所有值都不匹配时会没有输出，这种情况不好，容易让人摸不着头脑，为了避免这种情况一般都加上default。

2、case穿透

因为case语句中没有写break，无法跳出switch，会继续执行所有的case语句中的语句体，直到方法结束或者遇到break。利用这一特性我们可以少写一些代码。

3、JDK12的switch新特性：简化switch的书写

具体怎么简化的呢？

①将冒号:改为->

②省略break，然后将语句体用大括号括起来，而且如果语句体只有一句，那大括号也可以省略。

有一个问题，就是我发现总是可以这样省略大括号，但是到了后面我根本就记不得什么时候可以省，什么时候不可以省。很烦。或者这样想，如果语句体只有一句那么大括号自然可以省略。

switch(条件表达式){
    case 值1 -> {
        语句体1;
    }
    case 值2 -> {
        语句体2;
    }
        ...
    default -> {
        语句体3;
    }
}

//语句体只有一句时省略大括号
switch(条件表达式){
    case 值1 -> 语句体1;
    case 值2 -> 语句体2;
        ...
    default -> 语句体3;
    }
}

4、if的第三种格式和switch分别什么时候使用呢？

判断一个变量属于众多条件中的哪一个。

if一般是判断变量是否属于某个范围，而switch则一般是判断变量是哪个值。

复习了switch以后新写的代码，感觉也不是很简洁。

import java.util.Scanner;

public class TestDemo2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入机票的价格：");
        int ticket = scanner.nextInt();
        System.out.println("请输入当前的月份：");
        int month = scanner.nextInt();
        System.out.println("请输入机票的舱位：0 经济舱；1 头等舱");
        int seat = scanner.nextInt();
        System.out.println(price(ticket,month,seat));
    }
    static int price(int ticket,int month,int seat){
        switch (month){
            case 1:
            case 2:
            case 3:
            case 4:
                ticket = getTicket(seat,ticket,0.65,0.7);
                break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                ticket = getTicket(seat,ticket,0.85,0.9);
                break;
            case 11:
            case 12:
                ticket = getTicket(seat,ticket,0.65,0.7);
                break;
        }
        return ticket;
    }
    private static int getTicket(int seat, int ticket, double x, double x1) {
        if (seat == 0) {
            ticket = (int) (ticket * x);
        }
        if (seat == 1) {
            ticket = (int) (ticket * x1);
        }
        return ticket;
    }
}

在这个例子中将if和switch进行比较，发现还是if比较方便。

IDEA中有一个快捷键：crtl+alt+M，抽取代码使其称为一个方法。

需求2：找出100-200之间的所有素数。

（这道题找素数更没什么好说的了，只不过额外将判断一个数是否为素数抽取为一个方法，然后遍历100-200中的每个数调用此方法进行判断就好了）

public class TestDemo3 {
    //如何判断1个数是否为素数,将其抽取为方法
    //循环100-200，调用此方法
    public static void main(String[] args) {
        for (int i = 100; i <= 200 ; i++) {
            if(isPrime(i)){
                System.out.println(i);
            }
        }
    }
    static boolean isPrime(int num){
        boolean flag = true;
        for (int i = 2; i < num; i++) {
            if (num % i == 0) {
                flag = false;
            }
        }
        return flag;
    }
}

这里我写的少了一点，就是当存在可以整除的因子时就可以判断出这个数不是素数了，应该立即跳出循环，所以可以加上break，结束循环，代码如下。

public class TestDemo3 {
    //如何判断1个数是否为素数,将其抽取为方法
    //循环100-200，调用此方法
    public static void main(String[] args) {
        for (int i = 100; i <= 200 ; i++) {
            if(isPrime(i)){
                System.out.println(i);
            }
        }
    }
    static boolean isPrime(int num){
        boolean flag = true;
        for (int i = 2; i < num; i++) {
            if (num % i == 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }
}

需求3：定义方法实现随机产生一个5位的验证码
验证码格式:
长度为5
前四位是大写字母或者小写字母
最后一位是数字

（看到这个题目时我是没有一点想法的，因为把如何使用随机数也给忘记了，所以看视频讲解，重点在如何把52个大小写英文字母给放到数组中，为何能放是因为英文字母和数字是由对应关系的）

将52个大小写的英文字母放到数组中，然后随机抽取。

public class TestDemo4 {
    public static void main(String[] args) {
        char[] chars = new char[52];
        for (int i = 0; i < 52; i++) {
            if(i < 26) {
                chars[i] = (char) (65 + i);
            }
            else {
                chars[i] = (char) (97 + i - 26);
            }
        }
        String s = "";
        Random r = new Random();
        for (int i = 0; i < 5; i++) {
            if(i < 4){
                int num = r.nextInt(chars.length);
                s = s + chars[num];
            }
            else {
                int num = r.nextInt(10);
                s = s + num;
            }
        }
        System.out.println(s);
    }

}

 三、如何产生随机数？

1、创建一个Random对象

2、调用nextInt(L)方法并传入一个参数，此参数表示产生的随机数的范围是[0,L-1]。

需求4：复制一个数组中的数到新数组中

（这个更没啥好说的）

public class TestDemo5 {
    public static void main(String[] args) {
        int[] arr1 = {11,22,33,44,55};
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

 需求5：在唱歌比赛中，有6名评委给选手打分，分数范围是[0-100]之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。

（我只关注了如何计算选手的得分，但是视频对题目提出了另外一个要求：就是要键盘录入评委的打分，而我是直接利用数组给出的，这里我并没有很重视，只关注不合法时给出提示，其实是要重新输入的。

而且我们求解的思路也不太一样，我是记录了最大值和最小值的下标，然后求和的时候不加上这两个值，视频里是获取最大值和最小值，然后将所有数加到一起求和之后再减去最大值和最小值。）

public class TestDemo6 {
    public static void main(String[] args) {
        int[] arr = {98,78,89,86,95,67};
        int max = 0, min = 0, max_index = 0, min_index= 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max){
                max_index = i;
            }
            if(arr[i] < min){
                min_index = i;
            }
        }
        int sum = 0, average = 0;
        for (int i = 0; i < arr.length; i++) {
            if((i != max_index) && (i != min_index)) {
                sum = sum + arr[i];
            }
        }
        average = sum/(arr.length - 2);
        System.out.println(average);
    }
}

我这里还有一个错误就是找最小值的时候，这里我将min初始化为0，那么6位评委的评分按理说是不会比0小的，所以min的值始终为0，是错误的，这里我们将min的值初始化为数组中0索引处的值。

import java.util.Scanner;

public class TestDemo7 {
    public static void main(String[] args) {
        //录入6为评委的评分
        Scanner scanner = new Scanner(System.in);
        int[] score = new int[6];
        for (int i = 0; i < 6;) {
            System.out.println("请输入第" + (i+1) + "个评委打分：");
            if(score[i] < 0 || score[i] >100){
                System.out.println("您输入的数据不合法！");
            }
            else {
                score[i] = scanner.nextInt();
                i++;
            }
        }
        System.out.println(getAverage(score));
    }
    public static int getMax(int[] arr){
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
    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;
    }
    public static int getAverage(int[] arr){
        int sum = 0, average = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        average = (sum - getMax(arr) - getMin(arr))/ (arr.length - 2);
        return average;
    }
}

 这里方法的定义和调用有些混乱吧，不是那么清晰。

四、获取一组数中的最小值

这个之所以加到上面是因为我写错了，以防后面再写错，加深一下印象。

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

需求6：某系统的数字密码(大于0)，比如1983，采用加密方式进行传输。
规则如下:
先得到每位数，然后每位数都加上5，再对10求余，最后将所有数字反转，得到一串新数。 

public class TestDemo8 {
    public static void main(String[] args) {
        int num = 1983;
        int x = 0;
        int newNum = 0;
        while (num != 0) {
            //先得到每位数
            x = num % 10;
            //每位数加上5然后再对10求余
            x = (x + 5) % 10;
            //为得到下一个做准备
            num = num / 10;
            //进行反转
            newNum = newNum * 10 + x;
            System.out.println(newNum);
        }
        //System.out.println(newNum);
    }
}

刚开始反转不会写，后面看了视频抄的才写出来：newNum = newNum * 10 + x;

五、如何将一个数中的每位数按序存到数组当中去？

有两点需要注意：

1、首先要创建一个数组，但是创建一个数组需要给出数组的长度，所以要有一个方法知道一个数有几位。

2、得到一个数的每位数一般是从个位数开始的，然后将个位数1放到数组中的最后一位，即从后往前方。 

import java.util.Scanner;

public class TestDemo9 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个数字：");
        int num = sc.nextInt();
        int[] newArr = reverseArray(num);
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i]);
        }
    }
    //计算一个数的位数
    static int numberOfDigits(int num){
        int temp = num;
        int k = 0;
        while(temp != 0){
            temp = temp / 10;
            k++;
        }
        return k;
    }
    //将一个数的每位数正序存放到数组中
    static int[] numberToArray(int num){
        int k = numberOfDigits(num);
        int[] arr = new int[k];
        int i = arr.length - 1;
        while(num != 0){
            int x = num % 10;
            arr[i] = x;
            i--;
            num = num / 10;
        }
        return arr;
    }
    //将数组逆序，如7856，逆序为6587
    static int[] reverseArray(int num){
        int[] arr = numberToArray(num);
        int temp = 0;
        for (int i = 0,j = arr.length - 1; i < j; i++,j--) {
            temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        return arr;
    }
}

六、while语句

 关于while循环，我总是存在一个问题，就是习惯自己去算循环的次数，但这样其实是很没必要的，因为while循环就是因为不考虑循环的次数才被选择的，但是又习惯用while语句去统计循环的次数然后得到一个有用的信息，导致我在用while循环的时候很难受。那么在用while循环的时候应该着重考虑什么呢？没思考出来，还是不熟练。

七、逆序一个数组中的数

定义两个指针i和j，分别指向数组的第一个和最后一个元素，然后交换i和j指向的元素，当i大于或等于j时就可结束交换了，为什么？

（1）当数组的长度是偶数时：

此种情况下，当i和j向前走到第三步时 ，此时的j是大于i的，然后数组中的四个元素也已完成交换。

（2）当数组的长度是奇数时：

从上面两种情况可以看到， 当j大于等于i时循环就可以停止了，并且已经完成数组元素的逆序。

需求7：对需求6进行解密

import java.util.Scanner;

public class TestDemo10 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个数字：");
        int num = sc.nextInt();
        int[] b = decNumber(num);
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]);
        }

    }
    //计算数的位数
    static int lengthOfNumber(int num){
        int k = 0;
        while (num != 0){
            k++;
            num = num / 10;
        }
        return k;
    }
    //将数正序放到数组中
    static int[] numberToArray(int num){
        int k = lengthOfNumber(num);
        int[] arr = new int[k];
        int x = 0, index = arr.length - 1;
        while (num != 0){
            x = (num % 10);
            arr[index] = x;
            index--;
            num = num / 10;
        }
        return arr;
    }
    //逆序数组
    static int[] reverseArray(int num){
        int[] arr = numberToArray(num);
        int temp = 0;
        for (int i = 0,j = arr.length - 1; i <j ; i++,j--) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        return arr;
    }
    //解密规则：
    static int[] decNumber(int num){
        int[] arr = reverseArray(num);
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            if((arr[i] >= 5) && (arr[i] <= 9)){
                newArr[i] = arr[i] - 5;
            }
            else if((arr[i] >= 0) && (arr[i] <= 4)){
                newArr[i] = arr[i] + 5;
            }
        }
        return newArr;
    }
}

需求8：一个大V直播抽奖，奖品是现金红包，分别有(2,588,888,1000,10000)五个奖金。请使用代码模拟抽奖打印出每个奖项，奖项的出现顺序要随机且不重复。打印效果如下:(随机顺序，不一定是下面的顺序)

（这个代码写的有问题，就是我一开始想用一个数组b去记录已经抽过的奖的下标，然后再次抽奖的时候和数组b里的数进行比对，如果已经抽到过，那么就需要再抽一次，但是这里我不知道怎解决了，而是只给出了没抽到过的怎么解决）

import java.util.Random;

public class TestDemo11 {
    public static void main(String[] args) {
        int[] arr = {2,588,888,1000,10000};
        for (int i = 0; i < arr.length; i++) {
            System.out.println("第" + (i+1) + "次抽奖");
            int num = Lottery(i,arr);
            System.out.println(arr[num] + "元的奖金被抽出");
        }

    }
    static int Lottery(int k,int[] arr){
        Random r = new Random();
        //num表示的是抽奖数组的下标
        int num = r.nextInt(5);
        //数组b记录的是抽过的奖的下标
        int[] b = new int[arr.length];
        boolean flag = true;
        for (int i = 0; i < b.length; i++) {
            if(num == b[i]){
                flag = false;
            }
        }
        if(flag){
            b[k] = num;
        }
        return num;
    }
}

看视频给出一个就解决办法，首先判断是否被抽到过（怎么判断是否被抽到过？用一个数组去存放抽到过的奖品金额，如果抽到过返回true，没抽到返回false）如果抽到过是要再抽一次，我们如何实现这个功能呢？答案就是将i++移到一个if判断里，只有抽到的是没抽过的才+1。

方法一：

import java.util.Random;

public class TestDemo11 {
    public static void main(String[] args) {
        int[] arr = {2,588,888,1000,10000};
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length;) {
            Random r = new Random();
            int index = r.nextInt(arr.length);
            int prize = arr[index];
            boolean flag = contains(newArr,prize);
            if(!flag){
                newArr[i] = arr[index];
                System.out.println(arr[index] + "元的奖金被抽出");
                i++;
            }
        }
    }
    //判断奖是否被抽到过，用newArr数组来存放已经抽过的奖
   static boolean contains(int[] arr,int prize){
       boolean flag = false;
       for (int i = 0; i < arr.length; i++) {
           if(prize == arr[i]){
               flag = true;
           }
       }
       return flag;
   }
}

再看这个代码发现和我的思路是相似的，但我的有些混乱。 

在这个示例中我学会了一个新知识点，就是for循环的i++可以拿出来放到if语句里，只有满足一些条件时才++。

 方法二：这个方法只是打乱了数组而已。

import java.util.Random;

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

需求9：投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1-33中选择;蓝色球号码从1-16中选择。 

要求：随机生成中奖号码
           用户输入中奖号码
           判断中奖情况 

（1）判断某个数在数组中是否存在

static boolean contains(int[] arr, int num){
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            if(num == arr[i]){
                flag = true;
            }
        }
        return flag;
    }

（2）写随机生成中奖号码的代码是没有问题的：

    //随机生成中奖号码
    static int[] createNumber(){
        //首先创建一个数组存7位数
        int[] numbers = new int[7];
        Random r = new Random();
        //然后生成6个红球号码且号码不能重复，号码范围：1-33
        for (int i = 0; i < numbers.length;) {
            int redNumber = r.nextInt(33) + 1;
            //判断生成的数是否已经存在
            boolean flag = contains(numbers, redNumber);
            if(!flag){
                numbers[i] = redNumber;
                i++;
            }
        }
        //生成1个蓝色球号码，可以和红色球号码重复，号码范围：1-16
        int blueNumber = r.nextInt(15) + 1;
        numbers[numbers.length - 1] = blueNumber;
        return numbers;
    }

（3）但是用户输入中奖号码这个我写的有问题：

    //用户输入中奖号码
    static int[] inputNumber(){
        int[] numbers = new int[7];
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入您的号码：");
        for (int i = 0; i < numbers.length; i++) {
            int number = sc.nextInt();
            //判断用户输入的红色球号码是否合法
            if (i < numbers.length - 1) {
                if ((number < 1) || (number > 33)) {
                    System.out.println("您输入的号码不合法！");
                }
            }
            //判断用户输入的蓝色球号码是否合法
            if ((number < 1) || (number > 16)) {
                System.out.println("您输入的号码不合法！");
            }
            numbers[i] = number;
        }
        return numbers;
    }

分析我上述的代码就可以发现，我是想在用户输入不合法的数据时进行提示，就是只进行了提示，不合法的数据依然存进了数组当中。但是却忘了一点，就是用户输入不合法的数据时是要重新回到输入的，所以依然应用上面的一个点：就是对某个条件进行判断，只有满足某些条件时才++，否则就回滚到之前的状态嘛。

这个是正确的代码：

//用户输入中奖号码
    static int[] inputNumber(){
        int[] numbers = new int[7];
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入您的号码：");
        //判断用户输入的红色球号码是否合法
        for (int i = 0; i < numbers.length - 1;) {
            int redNumber = sc.nextInt();
            //判断用户输入的红色球号码是否合法
            boolean flag = contains(numbers,redNumber);
            if(!flag){
                if ((redNumber < 1) || (redNumber > 33)) {
                    System.out.println("您输入的号码不合法！");
                }
                else {
                    numbers[i] = redNumber;
                    i++;
                }
            }
            else {
                System.out.println("当前号码您已输入过！");
            }
        }
        //判断用户输入的蓝色球号码是否合法
        while (true) {
            int buleNumber = sc.nextInt();
            if ((buleNumber >= 1) && (buleNumber <= 16)) {
                numbers[numbers.length - 1] = buleNumber;
                break;
            } else {
                System.out.println("您输入的号码不合法！");
            }
        }
        return numbers;
    }

这个代码是在视频中看到的，非常的好。

首先不仅考虑了用户输入的数据是否在范围之内，也考虑了用户输入的数据是否有重复，这点我并没有考虑到。 如何实现的呢？是两层if语句嵌套。关于for循环是可以多次判断的，然后如果只有一个东西需要判断，然后不符合就重新来的话可以使用while循环，即在判断的外面套上一层while(true)，如果满足条件的话就break出循环，否则一直循环。

Tips： 

①经过总结可以发现，有一个条件，只考虑满足条件时怎么做，不满足时自然重头来过，适合用for和while的例子，而且不论是什么样的条件，比如需求8中的判断是否重复，还是这个例子中的是否在范围之内。

②crtl+alt+T：为某一段代码自动加上for、while循环，if else语句以及try catch语句。

（4）判断中奖情况：

//判断中奖情况
    static void isWinning(int[] numbers1){
        int[] numbers2 = inputNumber();
        int redCount = 0, blueCount = 0;
        for (int i = 0; i < numbers1.length; i++) {
            if(i < numbers1.length - 1){
                if(numbers2[i] == numbers1[i]){
                    redCount++;
                }
            }
            else {
                if(numbers2[i] == numbers1[i]){
                    blueCount++;
                }
            }

        }
        if((redCount == 0) && (blueCount == 0)){
            System.out.println("您没有中奖！");
        }
        if((redCount == 1) && (blueCount == 1)){
            System.out.println("奖金为5元");
        }
        if(((redCount == 2) && (blueCount == 1)) || ((redCount == 3) && (blueCount == 1)) || ((redCount == 4) && (blueCount == 0))) {
            System.out.println("奖金为10元");
        }
        if(((redCount == 4) && (blueCount == 1)) || ((redCount == 5) && (blueCount == 0))) {
            System.out.println("奖金为200元");
        }
        if((redCount == 5) && (blueCount == 1)){
            System.out.println("奖金为3000元");
        }
        if((redCount == 6) && (blueCount == 0)){
            System.out.println("奖金为500万元");
        }
        if((redCount == 6) && (blueCount == 1)){
            System.out.println("奖金为1000万元");
        }
    }

这个代码存在一个问题就是我是按顺序进行判断的，但在实际情况中是不按顺序的。而且仔细研究中奖情况的球发现并不是所有的情况都涵盖在内，所以我的多个if并列并不是很好，要用else。所以要进行修改。

修改后的代码如下：

static void isWinning(int[] numbers1){
        //其中numbers1是中奖号码
        //其中numbers2是用户输入的号码
        int[] numbers2 = inputNumber();
        int redCount = 0, blueCount = 0;
        //将用户输入的号码和中奖号码一个一个进行比对
        //判断红球相同的个数
        for (int i = 0; i < numbers2.length - 1; i++) {
            for (int j = 0; j < numbers1.length - 1; j++) {
                if (numbers1[i] == numbers2[j]) {
                    redCount++;
                }
            }
        }
        //判断蓝球相同个数
        if (numbers2[numbers2.length - 1] == numbers1[numbers1.length - 1]) {
            blueCount++;
        }
        if((redCount == 1) && (blueCount == 1)){
            System.out.println("奖金为5元");
        } else if(((redCount == 2) && (blueCount == 1)) || ((redCount == 3) && (blueCount == 1)) || ((redCount == 4) && (blueCount == 0))) {
            System.out.println("奖金为10元");
        } else if(((redCount == 4) && (blueCount == 1)) || ((redCount == 5) && (blueCount == 0))) {
            System.out.println("奖金为200元");
        } else if((redCount == 5) && (blueCount == 1)){
            System.out.println("奖金为3000元");
        } else if((redCount == 6) && (blueCount == 0)){
            System.out.println("奖金为500万元");
        } else if((redCount == 6) && (blueCount == 1)){
            System.out.println("奖金为1000万元");
        }else {
            System.out.println("您没有中奖！");
        }
    }

 整体代码如下：

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

public class TestDemo13 {
    public static void main(String[] args) {
        int[] numbers = createNumber();
        System.out.print("中奖号码为：");
        for (int i = 0; i < numbers.length; i++) {
            if(i == numbers.length - 1) {
                System.out.println(numbers[i] + " ");
            }
            else {
                System.out.print(numbers[i] + " ");
            }
        }
        isWinning(numbers);
    }
    //随机生成中奖号码
    static int[] createNumber(){
        //首先创建一个数组存7位数
        int[] numbers = new int[7];
        Random r = new Random();
        //然后生成6个红球号码且号码不能重复，号码范围：1-33
        for (int i = 0; i < numbers.length;) {
            int redNumber = r.nextInt(33) + 1;
            //判断生成的数是否已经存在
            boolean flag = contains(numbers, redNumber);
            if(!flag){
                numbers[i] = redNumber;
                i++;
            }
        }
        //生成1个蓝色球号码，可以和红色球号码重复，号码范围：1-16
        int blueNumber = r.nextInt(15) + 1;
        numbers[numbers.length - 1] = blueNumber;
        return numbers;
    }
    //判断某个数在数组中是否存在
    static boolean contains(int[] arr, int num){
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            if(num == arr[i]){
                flag = true;
            }
        }
        return flag;
    }
    //用户输入中奖号码
    static int[] inputNumber(){
        int[] numbers = new int[7];
        Scanner sc = new Scanner(System.in);
        //System.out.print("请输入您的号码：");
        //判断用户输入的红色球号码是否合法
        for (int i = 0; i < numbers.length - 1;) {
            System.out.println("第"+ (i+1) + "个号码：");
            int redNumber = sc.nextInt();
            //判断用户输入的红色球号码是否合法
            boolean flag = contains(numbers,redNumber);
            if(!flag){
                if ((redNumber < 1) || (redNumber > 33)) {
                    System.out.println("您输入的号码不合法！");
                }
                else {
                    numbers[i] = redNumber;
                    i++;
                }
            }
            else {
                System.out.println("当前号码您已输入过！");
            }
        }
        //判断用户输入的蓝色球号码是否合法
        while (true) {
            System.out.println("第"+ numbers.length + "个号码：");
            int buleNumber = sc.nextInt();
            if ((buleNumber >= 1) && (buleNumber <= 16)) {
                numbers[numbers.length - 1] = buleNumber;
                break;
            } else {
                System.out.println("您输入的号码不合法！");
            }
        }
        return numbers;
    }
    //判断中奖情况
    static void isWinning(int[] numbers1){
        //其中numbers1是中奖号码
        //其中numbers2是用户输入的号码
        int[] numbers2 = inputNumber();
        int redCount = 0, blueCount = 0;
        //将用户输入的号码和中奖号码一个一个进行比对
        //判断红球相同的个数
        for (int i = 0; i < numbers2.length - 1; i++) {
            for (int j = 0; j < numbers1.length - 1; j++) {
                if (numbers1[i] == numbers2[j]) {
                    redCount++;
                }
            }
        }
        //判断蓝球相同个数
        if (numbers2[numbers2.length - 1] == numbers1[numbers1.length - 1]) {
            blueCount++;
        }
        if((redCount == 1) && (blueCount == 1)){
            System.out.println("奖金为5元");
        } else if(((redCount == 2) && (blueCount == 1)) || ((redCount == 3) && (blueCount == 1)) || ((redCount == 4) && (blueCount == 0))) {
            System.out.println("奖金为10元");
        } else if(((redCount == 4) && (blueCount == 1)) || ((redCount == 5) && (blueCount == 0))) {
            System.out.println("奖金为200元");
        } else if((redCount == 5) && (blueCount == 1)){
            System.out.println("奖金为3000元");
        } else if((redCount == 6) && (blueCount == 0)){
            System.out.println("奖金为500万元");
        } else if((redCount == 6) && (blueCount == 1)){
            System.out.println("奖金为1000万元");
        }else {
            System.out.println("您没有中奖！");
        }
    }
}

八、给定两个元素不重复的数组，如何判断两个数组中相同元素的个数？ 

取出一个数组中的第一个元素，然后依次 与另外一个数组中的每个元素进行比较，由于数组中的元素各不相同所以可行，当有相同的就不好说了。

 for (int i = 0; i < numbers2.length - 1; i++) {
            for (int j = 0; j < numbers1.length - 1; j++) {
                if (numbers1[i] == numbers2[j]) {
                    redCount++;
                }
            }
        }

九、二维数组

 每次提到一个新的知识的时候，要关注如何定义什么的。

1、如何定义二维数组？

①静态定义：直接给出元素。

int[][] yearArrArr = {
                {22, 66, 44},
                {77, 33, 88},
                {25, 45, 65},
                {11, 66, 99}};

②动态定义：使用new，这种方式需要给出数组的长度。

int [][] arr = new int[3][4];
//或者不给出一位数组的长度
int [][] arr = new int[2][];
int [] a1 = {1,2,3};
int [] a2 = {4,5,6};
arr[0] = a1;
arr[1] = a2;

2、如何获取二维数组中的元素？

二维数组中的元素是一位数组。

a[i]：定位二维数组中的元素，也就是一维数组，其值是一维数组的地址；

a[i][j]：定位一维数组中的元素

3、二维数组的内存原理

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

我这里算成每个季度的平均营业额和平均季度营业总额了，不过没关系，重点不在这里。

public class TestDemo14 {
    public static void main(String[] args) {
        //静态初始化二维数组
        int[][] yearArrArr = {
                {22, 66, 44},
                {77, 33, 88},
                {25, 45, 65},
                {11, 66, 99}};
        //如何访问二维数组中的每个元素
        int totalSum = 0, yearAverage = 0;
        for (int i = 0; i < yearArrArr.length; i++) {
            int sum = 0, quarterAverage = 0;
            for (int j = 0; j < yearArrArr[i].length; j++) {
                sum = sum + yearArrArr[i][j];
                totalSum = totalSum + sum;
            }
            quarterAverage = sum / yearArrArr[i].length;
            System.out.println(quarterAverage);
        }
        yearAverage = totalSum / yearArrArr.length;
        System.out.println(yearAverage);
    }
}