学习视频：https://www.bilibili.com/video/BV1Cv411372m
如侵权，请私信联系本人删除

文章目录

黑马程序员Java学习笔记（二）
- 数组概述
- 数组定义方式一、访问、注意事项
- 数组定义方式二，元素默认值规则
- 数组遍历、元素求和
- 数组案例：求最值、猜数字、随即排名、冒泡排序
- 数组内存图、常见使用问题
- Debug工具使用
- 方法定义格式、常见问题
- 方法案例：求和、判断奇偶数、求最值
- 方法的内存原理
- 方法参数传递机制
- 方法参数传递的案例
- 方法重载、return关键字
- 编程训练-案例1：买飞机票
- 编程训练-案例2：找素数
- 编程训练-案例3：验证码
- 编程训练-案例4：数组的复制
- 编程训练-案例5：评委打分
- 编程训练-案例6：数字加密
- 编程训练-案例7：模拟双色球

黑马程序员Java学习笔记（二）

数组概述

数组就是用来存储一批同种类型数据的内存区域（可以理解为容器）

int[] arr = {10, 20, 30, 40, 50, 60};
String[] names = {"张三", "李四", "王五"};

数组定义方式一、访问、注意事项

静态初始化数组：定义数组的时候直接给数组赋值

//完整格式
数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...};
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] ages = new int[]{12, 24, 36};

//简化格式
数据类型[] 数组名 = {元素1, 元素2, 元素3...};
int[] ages = {12, 24, 36};

public class ArrayDemo1 {
    public static void main(String[] args) {
        // double[] scores = new double[]{88.9, 65.8, 94.3};
        double[] scores = {88.9, 65.8, 94.3};
        // int[] ages = new int[]{19, 22, 21};
        int[] ages = {19, 22, 21};
        // String[] names = new String[]{"张三", "李四", "王五"};
        String[] names = {"张三", "李四", "王五"};

        System.out.println(scores);
        System.out.println(ages);
        System.out.println(names);
    }
}

/*
运行结果：
 [D@43a25848
 [I@3ac3fd8b
 [Ljava.lang.String;@5594a1b5
*/

[表示是数组格式
D、I、Ljava.lang.String;表示的是数据类型
十六进制字符串则是标识数据在内存中的地址

特别注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型

数组的访问

		int[] ages = {19, 22, 21};
        // 访问
        System.out.println(ages[0]);
        // 赋值
        ages[0] = 36;
        System.out.println(ages[0]);
        // 获取数组长度
        System.out.println(ages.length);
        // 访问数组最大索引
        System.out.println(ages[ages.length - 1]);

数组的几个注意事项

数据类型[] 数组名也可以写成数据类型数组名[]
什么类型的数组必须存放什么类型的数据，否则报错
数组一旦定义出来，程序执行的过程中，长度、类型就固定了

数组定义方式二，元素默认值规则

数组的动态初始化

定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据

// 先定义
数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];

// 后赋值
arr[0] = 10;
System.out.println(arr[0]);

动态数据中元素没有赋值，会有一个默认值，int类型为0，double类型为0.0，String类型为null
在这里插入图片描述

public class ArrayDemo1 {
    public static void main(String[] args) {
        double[] scores = new double[3];
        System.out.println(scores[0]);
        scores[0] = 99.9;
        System.out.println(scores[0]);
        String[] names = new String[3];
        names[0] = "mochu7";
        names[2] = "末初";
        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
    }
}
/*
运行结果：
0.0
99.9
mochu7
null
末初
*/

注意：静态初始化数组和动态初始化数组不可以混用，如下这样是会报错的

int[] arrs = new int[3]{1, 2, 3}

数组遍历、元素求和

public class ExampleCode {
    public static void main(String[] args) {
        double sum = 0;
        double[] scores = {67.2, 52.5, 89.9, 92.3, 74.6};
        for(int i=0; i<scores.length; i++){
            System.out.println(scores[i]);
            sum += scores[i];
        }
        System.out.println("总成绩为：" + sum);
    }
}
/*
运行结果为：
67.2
52.5
89.9
92.3
74.6
总成绩为：376.5
*/

数组案例：求最值、猜数字、随即排名、冒泡排序

求最大值

public class ExampleCode {
    public static void main(String[] args) {
        int[] faceScore = {15, 9000, 10000, 20000, 9500, -5};
        int max = faceScore[0];
        for(int i=0; i<faceScore.length; i++){
            if(max < faceScore[i]){
                max = faceScore[i];
            }
        }
        System.out.println("最大值：" + max);
    }
}
/*
运行结果：
最大值：20000
*/

猜数字游戏

package com.example.code;
import java.util.Random;
import java.util.Scanner;

public class ExampleCode {
    public static void main(String[] args) {
        Random rd = new Random();
        Scanner sc = new Scanner(System.in);
        int[] nums = new int[5];
        for(int i = 0; i < nums.length; i++) {
            nums[i] = rd.nextInt(20) + 1;
        }
        OUT:
        while(true) {
            System.out.println("请输入你猜的数字(1-20)：");
            int guessNumber = sc.nextInt();
            for(int i = 0; i < nums.length; i++) {
                if(guessNumber == nums[i]) {
                    System.out.println("恭喜你！答对了，你猜的数字是：" + guessNumber);
                    break OUT; // 结束外循环
                }
            }
            System.out.println("当前猜测的数据，在数组中不存在，请重新猜测");
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
    }
}
/*
运行结果：
请输入你猜的数字(1-20)：
12
当前猜测的数据，在数组中不存在，请重新猜测
请输入你猜的数字(1-20)：
6
当前猜测的数据，在数组中不存在，请重新猜测
请输入你猜的数字(1-20)：
7
当前猜测的数据，在数组中不存在，请重新猜测
请输入你猜的数字(1-20)：
14
当前猜测的数据，在数组中不存在，请重新猜测
请输入你猜的数字(1-20)：
16
恭喜你！答对了，你猜的数字是：16
16	1	4	17	16	
*/

随机排名

package com.example.code;
import java.util.Random;
import java.util.Scanner;

public class ExampleCode {
    public static void main(String[] args) {
        int[] jobNumber = new int[5];
        Random rd = new Random();
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < jobNumber.length; i++) {
            System.out.println("请输入第" + (i + 1) + "员工的工号：");
            jobNumber[i] = sc.nextInt();
        }
        System.out.print("你输入的工号为：" + " ");
        for (int i = 0; i < jobNumber.length; i++) {
            System.out.print(jobNumber[i] + "\t");
        }
        for (int i = 0; i < jobNumber.length; i++) {
            int index = rd.nextInt(jobNumber.length);
            int temp = jobNumber[index];
            jobNumber[index] = jobNumber[i];
            jobNumber[i] = temp;
        }
        System.out.println("\n");
        for (int i = 0; i < jobNumber.length; i++) {
            System.out.print(jobNumber[i] + "\t");
        }
    }
}
/*
运行结果：
请输入第1员工的工号：
1234
请输入第2员工的工号：
7479
请输入第3员工的工号：
5117
请输入第4员工的工号：
9876
请输入第5员工的工号：
2469
你输入的工号为： 1234	7479	5117	9876	2469	

5117	2469	7479	9876	1234
*/

数组排序的技术

冒泡排序
选择跑徐
插入排序
…

数组搜索相关的技术

二分搜索
分块查找
哈希表查找
…

public class ExampleCode {
    public static void main(String[] args) {
        int[] arr = {2, 5, 3, 1};
        // 定义一个循环，控制比较轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 定一个循环，控制每轮比较次数
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 判断j当前位置的元素值是否大于后一个位置，若大于则交换
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

数组内存图、常见使用问题

Java内存介绍：

栈
堆
方法区
本地方法栈
寄存器

方法区：放Class文件的
栈内存：运行的方法、main方法、定义的变量
堆内存：对象

在这里插入图片描述

Debug工具使用

IDEA自带的断点调试(排错)工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。

Debug工具基本使用步骤：

在需要控制的代码左侧，点击一下，形成断点
选择使用Debug方式启动程序，启动后程序会在断点暂停
控制代码一行一行的往下执行

在这里插入图片描述

多个断点直接的跳转如下，点击左侧的Resume Program

在这里插入图片描述

方法定义格式、常见问题

方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用，提高代码复用性。

public class Demo1 {
    public static void main(String[] args) {
        int res = sum(55, 45); // 调用方法
        System.out.println(res);
    }

    public static int sum(int a, int b) {
        int c = a + b;
        return c;
    }
}

方法定义的完整格式：

修饰符 返回值类型 方法名(形参列表) {
	方法体代码(需要执行的功能代码)
	return 返回值;
}

public static int sum(int a, int b) {
     int c = a + b;
     return c;
}

修饰符： public static
返回值类型：int、double、String、void
方法名称：任意定义
形参列表：(参数1, 参数2)
返回值：return 需要返回的变量

调用格式：方法名(...)

方法格式的注意事项：

方法声明了具体的返回值类型，内部必须使用return返回对应类型的数据
形参列表可以有很多个，甚至可以没有；如果有多个形参必须用”,“隔开，且不能给初始化值
如果方法不需要返回结果，返回值类型必须声明成void()，此时方法内部不可以使用return返回数据。
方法的编写顺序无所谓(方法定义在调用位置的前后都可以)
方法与方法之间是平行关系，不能嵌套定义
方法的返回值类型为void(无返回值)，方法内则不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
return语句下面，不能编写代码，return之后的代码执行不到，属于无效代码
方法不调用就不执行，调用时必须严格匹配方法的参数情况
有返回值的方法调用时可以选择定义变量的接收结果，或者直接输出调用，甚至直接调用；无返回值方法的调用只能调用；

无参数无返回的方法

public class Demo1 {
    public static void main(String[] args) {
        print();
    }

    public static void print() {
        System.out.println("Hello,World");
        System.out.println("Hello,World");
        System.out.println("Hello,World");
    }
}

方法案例：求和、判断奇偶数、求最值

求和

public class Demo1 {
    public static void main(String[] args) {
        System.out.println("1-50的和：" + sum(50));
        System.out.println("1-100的和：" + sum(100));
    }

    public static int sum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}

判断奇偶数

public class Demo1 {
    public static void main(String[] args) {
        check(11);
        check(100);
    }

    public static void check(int n) {
        if (n % 2 == 0) {
            System.out.println(n + "是偶数");
        }else {
            System.out.println(n + "是奇数");
        }
    }
}

求最值

public class Demo1 {
    public static void main(String[] args) {
        int[] examScore = {78, 99, 123, 143, 98, 86, 112, 127, 65};
        int max = getArrayMaxNumber(examScore);
        System.out.println("数组最大值是：" + max);
    }

    public static int getArrayMaxNumber(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

方法的内存原理

方法的调用流程：

方法没有被调用的时候，在方法区中的字节码文件中存放
方法被调用的时候，需要进入到栈内存中运行

在这里插入图片描述

方法参数传递机制

值传递

在传输实参给方法的形参的时候，并不是传输实参变量本身，而是传输实参变量中存储的值，这就是值传递
– 实参：在方法内部定义的变量
– 形参：在定义方法时，”()“ 中所声明的参数

public class Demo1 {
    public static void main(String[] args) {
        int a = 10;
        change(a);
        System.out.println(a); // 10
    }
    public static void change(int a) {
        System.out.println(a); // 10
        a = 20;
        System.out.println(a); // 20
    }
}

引用传递

public class Demo1 {
    public static void main(String[] args) {
        int[] arrs = {10, 20, 30};
        change(arrs);
        System.out.println(arrs[1]); // 222
    }
    public static void change(int[] arrs) {
        System.out.println(arrs[1]); // 20
        arrs[1] = 222;
        System.out.println(arrs[1]); // 222
    }
}

通过地址传递，直接修改了该地址上的值

在这里插入图片描述

基本类型和引用类型的参数在传递的时候都是值传递
– 基本类型的参数传输存储的数据值
– 引用类型的参数传输存储的地址值

方法参数传递的案例

案例一：打印数组内容

public class Demo1 {
    public static void main(String[] args) {
        int[] ages = {10, 20, 30, 40};
        printArray(ages);
        int[] numbers = null;
        printArray(numbers);
        int[] numbers1 = {};
        printArray(numbers1);
    }
    public static void printArray(int[] arr) {
        System.out.print("[");
        if (arr != null && arr.length != 0) {
            for (int i = 0; i < arr.length; i++) {
                System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
            }
        }
        System.out.println("]");
    }
}

案例二：从数组中查询元素的索引返回

public class Demo1 {
    public static void main(String[] args) {
        // 从整型数组中查询某个索引返回，不存在返回-1
        int[] arr = {12, 24, 36, 41, 59};
        int index = searchIndex(arr, 40);
        System.out.println("您查询的数据索引是：" + index);
    }

    public static int searchIndex(int[] arr, int data) {
        for (int i = 0; i < arr.length; i++) {
            if (data == arr[i]) {
                return i;
            }
        }
        return -1;
    }
}

案例三：比较两个数组内容是否相同

public class Demo1 {
    public static void main(String[] args) {
        int[] arr1 = {10, 20, 30, 40, 50};
        int[] arr2 = {10, 20, 30, 41, 50};
        System.out.println(compareArray(arr1, arr2));
    }
    public static boolean compareArray(int[] arr1, int[] arr2) {
        if (arr1.length == arr2.length) {
            for (int i = 0; i < arr1.length; i++) {
                if(arr1[i] != arr2[i]) {
                    return false;
                }
            }
            return true;
        }else {
            return false;
        }
    }
}

方法重载、return关键字

方法重载：同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。

public class Demo1 {
    public static void main(String[] args) {
        fire();
        fire("岛国");
        fire("岛国", 100);
    }
    public static void fire() {
        System.out.println("默认发射一枚武器给米国");
    }
    public static void fire(String location) {
        System.out.println("默认发射一枚武器给" + location);
    }
    public static void fire(String location, int number) {
        System.out.println("默认发射" + number + "枚武器给" + location);
    }
}

使用方法重载的好处：
对于相似功能的业务场景：可读性好，方法名称相同提示是同一类型的功能，通过形参不同实现功能差异化的选择，这是一种专业的代码设计。
方法重载的识别技巧：
只要是同一个类中，方法名称相同，形参列表不同，那么他们就是重载的方法，其他的不管！（如：修饰符，返回值类型都无所谓）

形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称

return关键字的单独使用

return; 可以立即跳出并结束当前方法的执行；return关键字单独使用可以放在任何方法中。

public class Demo1 {
    public static void main(String[] args) {
        chu(10, 0);
    }

    public static void chu(int a, int b) {
        if (b == 0) {
            System.out.println("除数不能为0");
            return; //直接跳出当前方法
        }else {
         int c = a / b;
            System.out.println("结果是：" + c);
        }
    }
}

编程训练-案例1：买飞机票

在这里插入图片描述

package com.mochu.project1;
import java.util.Scanner;

public class BuyAirtTckets {
    public static void main(String[] args) {
        // 1、用户输入机票原价、月份、舱位类型
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入机票原价：");
        double price = sc.nextDouble();

        System.out.print("请输入月份（1-12）：");
        int month = sc.nextInt();

        System.out.print("请输入舱位类型：");
        String cabin = sc.next();

        System.out.println("机票的价格是：" + calcPrice(price, month, cabin) + "￥");
    }

    // 定义方法接收信息，统计优惠后的价格返回
    public static double calcPrice(double price, int month, String cabin) {
        // 旺季5-10月，淡季11-12月、1-4月
        if (month >= 5 && month <= 10) {
            // 旺季
            switch (cabin) {
                case "头等舱":
                    price *= 0.9;
                    break;
                case "经济舱":
                    price *= 0.85;
                    break;
                default:
                    System.out.println("对不起，您输入的舱位类型有误~");
                    price = -1;
            }
        }else if (month == 11 || month == 12 || month >= 1 && month <= 4){
            // 淡季
            switch (cabin) {
                case "头等舱":
                    price *= 0.7;
                    break;
                case "经济舱":
                    price *= 0.65;
                    break;
                default:
                    System.out.println("对不起，您输入的舱位类型有误~");
                    price = -1;
            }
        }else {
            System.out.println("对不起，您输入的月份有误~");
            return -1;
        }
        return price;
    }
}

在这里插入图片描述

编程训练-案例2：找素数

判断101~200之间有多少个素数，并输出所有素数
素数：除了1和它本身以外，不能被其它正整数整除，这就叫素数

package com.mochu.project1;

public class SearchPrimeNumber {
    public static void main(String[] args) {
        // 定义一个循环，遍历101-200之间的全部数字
        for (int i = 101; i <= 200 ; i++) {
            // 判断遍历当前这个数是否是素数
            boolean flag = true;
            for (int j = 2; j < i / 2 ; j++) {
                if(i % j == 0) {
                    flag = false;
                    break;
                }
            }
            if(flag) {
                System.out.print(i + "\t");
            }
        }
    }
}

编程训练-案例3：验证码

package com.mochu.project1;
import java.util.Random;

public class CreateVerifCode {
    public static void main(String[] args) {
        String code = createVerifCode(5);
        System.out.println("验证码：" + code);
    }
    // 定义一个方法返回一个随机验证码，返回值类型为String，形参int n位数
    public static String createVerifCode(int n) {
        String verifcode = "";
        Random rd = new Random();
        for (int i = 0; i < n; i++) {
            int type = rd.nextInt(3);
            switch(type) {
                case 0:
                    // 大写字符(ASCII 65-90)
                    char ch = (char) (rd.nextInt(26) + 65);
                    verifcode += ch;
                    break;
                case 1:
                    // 小写字符(ASCII 97-122)
                    char ch1 = (char) (rd.nextInt(26) + 97);
                    verifcode += ch1;
                    break;
                case 2:
                    // 数字(ASCII 48-57)
                    int num = rd.nextInt(10);
                    verifcode += num;
                    break;
            }
        }
        return verifcode;
    }
}

在这里插入图片描述

编程训练-案例4：数组的复制

在这里插入图片描述

package com.mochu.project1;

public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33, 44, 55};
        int[] arr2 = new int[arr1.length];
        arrayCopy(arr1, arr2);
        printArray(arr1);
        printArray(arr2);
    }

    public static void arrayCopy(int[] arr1, int[] arr2) {
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
    }

    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }
}

在这里插入图片描述

编程训练-案例5：评委打分

在这里插入图片描述

package com.mochu.project1;

import java.util.Scanner;

public class JudgeScore {
    public static void main(String[] args) {
        // 定义一个动态数组存储六位评委的分数
        int[] scores = new int[6];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            System.out.print("请输入第" + (i + 1) + "位评委的分数：");
            int score = sc.nextInt();
            scores[i] = score;
        }

        int max = scores[0];
        int min = scores[0];
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            if(scores[i] > max) {
                max = scores[i];
            }
            if(scores[i] < min) {
                min = scores[i];
            }
            sum += scores[i];
        }
        double result = (sum - max - min) * 1.0 / (scores.length - 2);
        System.out.println("选手最终得分是：" + result);
    }
}

在这里插入图片描述

编程训练-案例6：数字加密

在这里插入图片描述

package com.mochu.project1;
import java.util.Scanner;

public class NumberEncrypt {
    public static void main(String[] args) {
        System.out.print("请输入需要加密的数字个数：");
        Scanner sc = new Scanner(System.in);
        int length = sc.nextInt();
        int[] arr = new int[length];
        // 录入数组元素
        for (int i = 0; i < arr.length; i++) {
            System.out.print("请输入第" + (i + 1) + "位数字：");
            int number = sc.nextInt();
            arr[i] = number;
        }
        printArray(arr); // 打印数组
        // 数字加密
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }
        // 数组反转（逆序）
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        printArray(arr);
    }
    // 打印数组的方法
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }
}

在这里插入图片描述

编程训练-案例7：模拟双色球

在这里插入图片描述

package com.mochu.project1;
import java.util.Random;
import java.util.Scanner;


public class DoubleColorBall {
    public static void main(String[] args) {
        // 随机生成6个红球号码(1-33，不能重复)，随机一个蓝球号码(1-16)，采用数组将中奖号码封装起来。
        int[] lucknumbers = createLuckyNumber();
        // 用户输入七个双色球号码，作为用户选号
        int[] inputnumbers = userInputNumbers();

        judge(lucknumbers, inputnumbers);
    }
    // 判断中奖，判断红球、蓝球分别中了多少个数
    public static void judge(int[] lucknumbers, int[] inputnumbers){
        int redballcount = 0;
        int blueballcount = 0;
        // 统计红球中了多少个
        for (int i = 0; i < inputnumbers.length - 1; i++) {
            for (int j = 0; j < lucknumbers.length - 1; j++) {
                if(inputnumbers[i] == lucknumbers[j]) {
                    redballcount++;
                    break;
                }
            }
        }
        // 统计蓝球中了没中
        blueballcount = inputnumbers[inputnumbers.length - 1] == lucknumbers[lucknumbers.length - 1] ? 1 : 0;
        System.out.println("您的号码是：");
        printArray(inputnumbers);
        System.out.println("中奖号码是：");
        printArray(lucknumbers);
        System.out.println("您命中了" + redballcount + "个红球");
        System.out.println("您" + (blueballcount == 1 ? "命中了" : "没有命中") + "蓝球");
        // 判断奖励情况
        if(blueballcount == 1 && redballcount < 3) {
            System.out.println("恭喜您！，获得5元奖励~");
        }else if(blueballcount == 1 && redballcount == 3 || blueballcount == 0 && redballcount == 4) {
            System.out.println("恭喜您！获得10元奖励~");
        }else if(blueballcount == 1 && redballcount == 4 || blueballcount == 0 && redballcount == 5) {
            System.out.println("恭喜您！获得200元奖励~");
        }else if(blueballcount == 1 && redballcount == 5) {
            System.out.println("恭喜您！获得3000元奖励~");
        }else if(blueballcount == 0 && redballcount == 6) {
            System.out.println("恭喜您！获得500万奖励~");
        }else if(blueballcount == 1 && redballcount == 6) {
            System.out.println("恭喜您！获得1000万奖励~");
        }else {
            System.out.println("很遗憾，您没有获奖");
        }
    }
    // 录入用户生成号码
    public static int[] userInputNumbers() {
        int[] inputNumbers = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < inputNumbers.length - 1; i++) {
            System.out.print("请输入第" + (i + 1) + "个红球号码（1-33，要求不重复）：");
            inputNumbers[i] = sc.nextInt();
        }
        System.out.print("请输入篮球号码（1-16，要求不重复）：");
        inputNumbers[inputNumbers.length - 1] = sc.nextInt();

        return inputNumbers;
    }

    // 生成中奖号码
    public static int[] createLuckyNumber() {
        int[] numbers = new int[7];
        // 6个不重复的红球号码(1-33)
        Random rd = new Random();
        for (int i = 0; i < numbers.length - 1; i++) {
            // 需要判断当前这个随即号码之前是否出现过，如果出现过则需要重新生成一个号码直到不重复为止。
            while (true) {
                int data = rd.nextInt(33) + 1;
                boolean flag = true;
                for (int j = 0; j < i; j++) {
                    if(numbers[j] == data) {
                        flag = false;
                        break;
                    }
                }
                if(flag) {
                    numbers[i] = data;
                    break;
                }
            }
        }
        // 生成蓝球号码(1-16)
        numbers[numbers.length - 1] = rd.nextInt(16) + 1;
        return numbers;
    }
    // 遍历数组
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length -1 ? arr[i] : arr[i] + ", ");
        }
        System.out.println("]");
    }
}