目录 Java 基础语法 一、 Java 概述 1、 Java 跨平台原理 2、 Java 环境 2.1 JRE 2.2 JDK 2.3 配置环境 2.3.1 下载 2.3.2 安装 3、 第一个 Java 程序 3.1 开发程序 3.2 执行原理 4、 IDEA 集成开发 4.1 简介
- Java 基础语法
- 一、 Java 概述
- 1、 Java 跨平台原理
- 2、 Java 环境
- 2.1 JRE
- 2.2 JDK
- 2.3 配置环境
- 2.3.1 下载
- 2.3.2 安装
- 3、 第一个 Java 程序
- 3.1 开发程序
- 3.2 执行原理
- 4、 IDEA 集成开发
- 4.1 简介
- 4.2 使用
- 4.3 快速生成代码
- 二、 Java 基础
- 1、 注释
- 2、 字面量
- 3、 变量
- 4、 数据类型
- 5、 关键字
- 6、 标识符
- 7、 数据类型转换
- 7.1 自动类型转换
- 7.2 强制类型转换
- 三、 运算符
- 1、 算术运算符
- 2、 赋值运算符
- 3、 关系运算符
- 4、 逻辑运算符
- 5、 三元运算符
- 四、 流程控制
- 1、 顺序结构
- 2、 分支结构
- 2.1 if
- 2.2 switch
- 3、 循环结构
- 3.1 for
- 3.2 while
- 3.3 do...while
- 3.4 中断
- 3.4.1 break
- 3.4.2 continue
- 3.4.3 return
- 4、 随机数
- 5、 输入数据
- 五、 数组
- 1、 概念
- 2、 数组的定义
- 3、 数组的遍历
- 4、 数组排序
- 5、 Java 内存分配
- 六、 方法
- 1、 简介
- 2、 定义和调用
- 2.1 定义
- 2.2 调用
- 3、 参数传递
- 3.1 值传递
- 3.2 引用传递
- 4、 方法重载
- 七、 案例
- 1、 买飞机票
- 2、 找素数
- 3、 开发验证码
- 4、 数组元素复制
- 5、 评委打分
- 6、 数据加密
- 7、 模拟双色球
- 7.1 业务分析
- 7.2 用户输入一组蓝色号码
- 7.3 判断中奖情况
- 7.4 总代码
- 一、 Java 概述
在需要运行 Java 应用程序的操作系统上，安装一个与操作系统对应的 Java 虚拟机（JVM）即可
2、 Java 环境 2.1 JRE是 Java 程序运行时环境，包含 JVM 和运行时所需要的核心类库
我们想要运行一个已有的 Java 程序，那么只需安装 JRE 即可
2.2 JDK是 Java 程序开发工具包，包含 JRE 和开发人员使用的工具
其中的开发工具：编译工具（javac）和运行工具（java）
我们想要开发一个全新的 Java 程序，那么必须先安装 JDK
2.3 配置环境 2.3.1 下载通过官方网站获取 JDK：【https://www.oracle.com/java/technologies/downloads/】
2.3.2 安装针对不同操作系统，下载对应的 JDK
一路点击下一步即可
安装路径下不要包含中文和空格，所有开发工具最好安装目录统一
JDK 各目录作用
其余文件为说明文档
已知，我安装 JDK 的路径为 D:\Program Files\Java\jdk-17.0.2
在系统变量中添加以下值
-
CLASSPATH
-
.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar注意前面是有一个点的
-
-
JAVA_HOME
D:\Program Files\Java\jdk-17.0.2
-
Path 中添加
%JAVA_HOME%\jre\bin%JAVA_HOME%\bin
在 cmd 中输入
java -version出现版本号即表示安装成功
3、 第一个 Java 程序 3.1 开发程序
开发 Java 程序，需要三个步骤：编写程序、编译程序、运行程序
-
编写程序
public class first { public static void main (String[] args) { System.out.println("Hello World"); } } -
编译程序
在 cmd 中输入 javac 文件名.java javac first.java -
运行程序
在 cmd 中输入 java 文件名 java first
不管是什么样的高级编程语言，最终都是翻译成计算机底层可以识别的机器语言
4、 IDEA 集成开发 4.1 简介集成开发环境：
- 把代码编写、编译、执行等多种功能综合到一起的开发工具，可以进行代码智能提示、错误提醒、项目管理等等
IDEA 激活工具：【https://files.cnblogs.com/files/blogs/722174/IDEA.zip?t=1646960426】
4.2 使用IDEA 结构介绍
- project：项目、工程
- module：模块
- package：包
- class：类
- package：包
- module：模块
注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序
package demo001;
/**
文档注释
文档注释的内容是可以提取到一个程序说明文档中去的
*/
public class demo1 {
public static void main(String[] args) {
// 以下是打印程序，单行注释
System.out.println("hello");
/*
这是多行注释
*/
}
}
注释的特点
- 注释不影响程序的执行
计算机是用来处理数据的，字面量就是告诉程序员：数据在程序中的书写格式
package demo001;
/**
字面量
*/
public class demo1 {
public static void main(String[] args) {
// 整数
System.out.println(666);
// 小数
System.out.println(2.3);
// 字符，\n 换行字符，\t 水平制表位
System.out.println('A'); // 其自带了换行功能
System.out.println('\n'); // 换两行
// 字符串
System.out.println("ABC");
// bool 值
System.out.println(true);
}
}
3、 变量和 C++ 的字面量相同
变量就是用来存储一个数据的内存区域（可以理解成盒子），且里面存储的数据可以变化
语法：
数据类型 变量名称 = 初始值;
4、 数据类型注意：
- 变量要先声明再使用
- 变量声明后，不能存储其他类型的数据
- 变量的有效范围是从定义开始到 ";" 截止，且在同一个作用域内不能定义多个同名变量
- 变量定义的时候可以没有初始值，但是使用的时候必须给初始值
有两类：
-
引用数据类型：String
-
基本数据类型：4 大类 8种
类型名称 关键字 占用内存 取值范围 字节型 byte 1 字节 -128~127 短整型 short 2 字节 -32768~32767 整型 int（默认） 4 字节 -2147483648~2147483647 长整型 long 8 字节 -9223372036854775808L~9223372036854775807L 单精度浮点型 float 4 字节 +/-3.4E+38F（6~7 个有效位） 双精度浮点型 double（默认） 8 字节 +/-1.8E+308 (15 个有效位） 字符型 char 2 字节 ISO 单一字符集 布尔型 boolean 1 字节 true 或 false
5、 关键字
Java 自己保留的一些单词，作为特殊功能
我们不能使用关键字作为类名或者变量名称，否则报错
6、 标识符标识符就是由一些字符。符号组成起来的名称，用于给类、方法、变量等取名字的规矩
要求：
- 由数字、字母、下划线和美元符等组成
- 不能以数字开头，不能是关键字，区分大小写
命名规范：
- 变量名称： 满足标识符规则，建议全英文、有意义、首字母小写，满足驼峰命名法
- 类名称：满足标识符命名规则，建议全英文、有意义、首字母大写，满足驼峰命名法
类型范围小的变量，可以直接赋值给类型范围大的变量
byte a = 20;
int b = a;
System.out.println(b);
表达式类型自动转换：
byte a = 1;
double b = 1.2;
System.out.println(a + b);
7.2 强制类型转换小范围的类型会自动转换成大范围的类型运算
类型范围大的数据或者变量，不能直接赋值给类型范围小的变量，会报错；要通通过强制类型转换类实现
语法：
数据类型2 变量2 = (数据类型2)变量1
int a = 30;
byte b = (byte)a; // 强制转换
System.out.println(b);
三、 运算符 1、 算术运算符注意：
- 其可能会造成数据损失或溢出
运算符：对字面量或者变量进行操作的符号
"+" 加, "-" 减, "/" 除, "*" 乘, "%" 取余, "++" 递增, "--"递减
2、 赋值运算符两个整数相除结果是整数
加法与字符串运算的时候是用作 连接符的，其结果依然是一个字符串
++ 既可以放在变量后面，也可以放在变量前面
- 前面，先对变量进行算术运算，再进行其他运算
- 后面，先对变量进行其他运算，再进行算术运算
"=" 等于, "+=" 加等于 , "-=" 减等于 , "/=" 除等于 , "%=" 余等于 , "*=" 乘等于
其中，隐含了强制类型转换
byte i = 10, j = 20;
// i = (byte) (i + j);
i += j;
"=="等于 , "<=" 小于等于, ">=" 大于等于 , "!=" 不等于 , "<" 小于 , ">" 大于
4、 逻辑运算符5、 三元运算符逻辑与、逻辑或：无论左边是 false 还是 true，右边都要执行
短路与、。短路或：当左边可以判断结果时，不会执行右边的代码
语法：
条件吧表达式 ? 值1 : 值2；
执行流程：首先要计算关系表达式的值，如果值为 true，返回值1；如果值为 false ，返回值2
// 判断最大值
int k = 10, j = 30, i = 50;
int max = (k > j ? k : j) > i ? (k > j ? k : j) : i;
程序默认流程
2、 分支结构根据判定的结果（真或假）决定执行某个分支的代码
2.1 if语法：
if (条件表达式1) {
语句体1;
} else if (条件表达式2) {
语句体2;
} esle {
语句体3;
}
语法：
switch (表达式) {
case 值1:
执行代码1;
break;
case 值2:
执行代码2;
brreak;
default:
执行代码n;
}
3、 循环结构注意：
- 表达式类型只能是 byte、short、int、char，JDK5开始支持枚举，JDK7 支持 String、不支持 double、float、long
- case 给出的值不允许重复，且只能是字面量，不能是变量
- 不要忘记写 break，否则会出现穿透现象
控制一段代码反复执行很多次
3.1 for语法：
for (初始化语句; 循环条件; 迭代语句) {
循环语句;
}
语法：
while (循环条件) {
循环语句;
迭代语句;
}
3.3 do...while当不确定循环次数时，优先使用 while 循环；反之使用 for 循环
语法：
do {
循环语句;
迭代语句;
} while (循环条件)
终止循环
3.4.2 continue中断本次循环，进行下次循环
3.4.3 return跳出并立即结束所在方法的执行
4、 随机数Random随机数技术
作用：用于在程序中获取随机数
使用步骤：
-
导包
import java.util.Random; -
实例化对象
Random rd = new Random(); -
调用随机数
int num = rd.nextInt(10); // 获取 0 ~ 9 的整型随机数Random 生成随机数的技巧，使用减加法获取指定范围的随机数
也可以直接输入区间
Scanner键盘键入技术
作用：用于在程序中获取键盘输入的内容
使用步骤：
-
导包
import java.util.Scanner; -
实例化对象
Scanner sc = new Scanner(System.in); -
调用随机数
int num = sc.nextInt(); // 获取数字 String ch = sc.next(); // 获取字符串
数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）
- 数组适合做一些同种类型数据的存储
-
静态初始化数组
- 定义数组的时候直接给数组赋值
语法：
-
数据类型[] 数组名 = new 数据类型[]{ 元素1, 元素2 }; // 简化版本 数据类型[] 数组名 = { 元素1, 元素2 };注意事项：
数据类型[] 数组名也可以写成数据类型 数组名[]- 什么类型的数组就存放什么类型的数据，否则报错
- 数组一旦定义出来，程序执行的过程中，长度、类型就固定了
数组的访问
-
索引访问
语法：
-
数组名[索引];其也可以给数组赋值
-
-
数组长度属性
语法：
-
数组名.length; // 获取数组的长度最大索引是：arr.length - 1
-
-
动态初始化数组
- 定义数组的时候只确定元素的类型和数组长度，之后再存入具体数据
语法：
-
数据类型[] 数组名 = new 数据类型[长度];数组里面的元素默认值为 boolean 值为 false 所对应的数据类型
后赋值
-
数组名[索引] = 值;
-
区别
- 当前已经知道存入的元素值，用静态初始化
- 当前还不清楚要存入哪些数据，用动态初始化
- 两种格式的写法是独立的，不能混合使用
遍历：就是一个一个数据的访问
public class demo1 {
public static void main(String[] args) {
int[] arr = {0, 1, 2, 3, 4};
for (int i = 0; i < (arr.length); i++){
System.out.println(arr[i]); // for 循环遍历数组
}
}
}
冒泡排序思想：
- 每次从数组中找出最大值放在数组的后面去
实现冒泡排序的关键步骤：
- 确定总共需要做几轮：数组长度 - 1
- 每轮比几次：数组长度 - 1 - 已比较多少轮
package demo001;
public class demo1 {
public static void main(String[] args) {
int[] arr = {0, 1, 2, 5, 4};
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; 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.println(arr[i]);
}
}
}
-
栈区
方法运行时所进入的内存，变量也是存储在这里
-
堆区
new 出来的东西会在这块内存中开辟空间并生产地址
-
方法区
里面存储了定义的方法和类
方法是什么：
- 方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用
作用：
- 提高了代码的复用性
- 让程序逻辑更清晰
package demo001;
public class demo1 {
public static void main(String[] args) {
System.out.println(sum(2, 3));
}
public static int sum(int a, int b) {
return a + b;
}
}
语法：
修饰符 返回值类型 方法名(形参列表) {
方法体代码;
}
2.2 调用注意：
- 方法的修饰符：暂时使用 public static 修饰
- 方法申明了具体返回值类型，内部必须使用 return 返回对应类型的数据
- 形参列表可以有多个，甚至可以没有；如果有多个形参，多个形参必须用 "," 隔开，且不能给初始化值
- 方法定义时：返回值类型、形参按照需求来填写
语法：
方法名(参数);
在传输实参给方法的时候，并不是传输实参变量本身，而是传输实参变量中存储的值，这就是值传递
注意：
- 实参：在方法内部定义的变量
- 形参：在方法定义时，声明的参数
在传输实参给方法的时候，传递实参变量的地址给函数，函数内部修该变量，外部也会同步修改
4、 方法重载同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法
调用方法的时候，会通过参数的不同来区分调用的是哪个方法
作用：
- 可读性好
- 通过形参不同实现功能差异化的选择，是一种专业化的代码设计
需求分析：
- 机票价格按照淡季旺季、头等舱和经济舱收费、输入飞机票原价、月份和头等舱或经济舱
- 机票最终优惠价格的计算方案如下：
- 旺季（5~10月）：头等舱9折、经济舱8.5折
- 淡季（11月~4月）：头等舱7折、经济舱6.5折
实现思路：
- 键盘录入机票的原价，仓位类型、月份信息，调用方法返回机票最终的优惠价格
- 方法内部应该先使用 if 分支判断月份是在淡季还是旺季，然后使用 switch 分支判断是头等舱还是经济舱
package demo001;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
// 用户输入信息
Scanner sc = new Scanner(System.in);
System.out.println("请输入机票的原价：");
double price = sc.nextDouble();
System.out.println("请输入机票的月份：");
int month = sc.nextInt();
System.out.println("请输入舱位类型：\n1. 头等舱\n2. 经济舱");
int type = sc.nextInt();
System.out.println(calc(price, month, type));
}
public static double calc(double price, int month, int type) {
if (!(month > 0 && month < 13 && type > 0 && type < 3 && price > 0)) {
System.out.println("您输入有误，请重新输入！！！");
return 0;
}
if (month > 4 && month < 11) {
// 4 < month < 11
switch (type) {
case 1:
price *= 0.9;
break;
case 2:
price *= 0.85;
break;
}
} else {
// 11 ~ 4
switch (type) {
case 1:
price *= 0.7;
break;
case 2:
price *= 0.65;
break;
}
}
return price;
}
}
判断 101 ~ 200 之间有多少个素数，并输出所有素数
分析：
- 101 ~ 200 之间的数据可以采用循环依次拿到；每拿到一个数，判断该数是否是素数
- 判断规则是：从2开始遍历到该数的一半数据，看是否有数据可以整除它，有则不是素数，没有则是素数
package demo001;
public class demo1 {
public static void main(String[] args) {
for (int i = 101; i < 201; i++) {
boolean flag = true; // 信号位，默认为素数
for (int j = 2; j < (i / 2); j++) {
if ((i % j) == 0) {
flag = false;
break;
}
}
if (flag) {
System.out.println(i + "该数为素数");
}
else {
System.out.println(i + "该数不是素数");
}
}
}
}
需求：
- 定义一个方法实现随机产生一个 5 位的验证码，每位可能是数字、大写字母、小写字母
分析：
- 定义一个方法，生成验证码返回：方法参数是位数、方法返回值类型是 String
- 在方法内部使用 for 循环生成指定位数的随机字符，并连接起来
- 把连接好的随机字符作为一组验证码进行返回
package demo001;
import java.util.Random;
public class demo1 {
public static void main(String[] args) {
System.out.println(verify(5));
}
public static String verify(int n) {
String verify = ""; // 接收生成的验证码
Random r = new Random();
for (int i = 0; i < n; i++) {
// 生成随机字符
int type = r.nextInt(3); // 0 1 2 分别对应英文大小写，数字
switch (type) {
case 0:
// 英文大写 A~Z 65~65+25
char ch = (char) (r.nextInt(26) + 65);
verify += ch;
break;
case 1:
// 英文小写 a~z 97~97+25
char cr = (char) (r.nextInt(26) + 97);
verify += cr;
break;
case 2:
// 数字 0~9
int ci = r.nextInt(10);
verify += ci;
}
}
return verify;
}
}
需求：
- 把一个数组中的元素复制到另一个新数组中去
分析：
- 需要动态初始化一个数组，长度与原数组一样
- 遍历原数组的每个元素，依次赋值给新数组
- 输出两个数组的内容
package demo001;
public class demo1 {
public static void main(String[] args) {
int[] arr1 = {11, 22, 33, 44};
int[] arr2 = new int[arr1.length];
copy_arr(arr1, arr2);
printArr(arr1);
printArr(arr2);
}
public static void printArr(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("]");
}
public static void copy_arr(int[] arr, int[] arr2) {
for (int i = 0; i < arr.length; i++) {
arr2[i] = arr[i];
}
}
}
需求：
- 在唱歌比赛中，有 6 名评委给选手打分，分数范围是 [0, 100] 之间的整数。选手的最后得分为：去掉最高分和最低分后的四名评委的平均分
分析：
- 把 6 个评委的打分录入到一个数组中去
- 遍历数组中每个数据，进行累加求和，并找出最高分、最低分
- 按照分数的计算规则算出平均分
package demo001;
import java.util.Random;
public class demo1 {
public static void main(String[] args) {
int[] score = new int[6];
playScore(score);
printArr(score);
sum(score);
}
public static void playScore(int[] arr) {
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
// 使用随机数表示
arr[i] = r.nextInt(101);
}
}
public static void printArr(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("]");
}
public static void sum(int[] arr) {
int max = arr[0], min = arr[0], sum = 0;
for (int i = 0; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
if (min > arr[i]) {
min = arr[i];
}
sum += arr[i];
}
int sum1 = sum - min - max;
System.out.println(sum + " - " + min + " - " + max + " = " + sum1); // 输出最值
System.out.println("平均分为：" + sum1 * 1.0 / (arr.length - 2)); // 平均分
}
}
需求：
-
某系统的数字密码：比如1983 --> 8346，采用加密方式进行传输，规则如下：
- 先得到每位数，然后每位数都加上 5，再对 10 取余，最后将所有数字反转，得到一串新数
分析：
- 将每位数据存入到数组中去，遍历数组每位数据，按照规则进行修改，把更改后的数据重新存入数组中
package demo001;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
System.out.println("请您输入要加密的数字");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int[] arr = new int[getBit(num)], arr_encrypt = new int[getBit(num)];
getIntArr(arr, num); // 得到整型数组
printArr(arr); // 输出数组
encrypt(arr, arr_encrypt); // 加密数组
printArr(arr_encrypt); // 输出加密后的数组
}
private static int getBit(int num) {
// 获取数字的位数
if (num == 0) {
return 1;
}
int length = 0;
for (int i = num; i != 0; i /= 10) {
length++;
}
return length;
}
private static void getIntArr(int[] arr, int num) {
for (int i = 0; i < arr.length; i++) {
arr[arr.length - i - 1] = num / ((int) Math.pow(10, i)) % 10; // 得到数字的每一位
}
}
private static void printArr(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("]");
}
private static void encrypt(int[] arr, int[] encrypt_arr) {
for (int i = 0; i < arr.length; i++) {
// 加密
encrypt_arr[arr.length - i - 1] = (arr[i] + 5) % 10;
}
}
}
7、 模拟双色球 7.1 业务分析同时其也是解密程序
投注号码由 6 个红色球号码 1 个蓝色球号码组成。红色球号从 1 - 33 中选择；蓝色球号从 1 - 16 中选择
随机生成一组中奖号码：
- 中奖号码由 6 个红球和 1 个蓝色组成（注意：6个红球不能重复）
- 可以定义方法用于返回一组中奖号码（7个数据），返回的形式是一个整型数组
package demo001;
import java.util.Random;
public class demo1 {
public static void main(String[] args) {
int[] arr = createLuckNum();
printArr(arr);
}
private static int[] createLuckNum() {
// 定义一个动态初始化的数组，有 7 个数字
int[] num = new int[7];
Random r = new Random();
// 红球赋值
for (int i = 0; i < 6; i++) {
// 注意要判断数字是否出现过
while (true) {
int data = r.nextInt(33) + 1;
boolean flag = true; // 默认没有重复
for (int j = 0; j < i; j++) {
if (num[j] == data) {
flag = false;
break;
}
}
if (flag) {
// 没有重复
num[i] = data;
break;
}
}
}
// 生成蓝色号码
num[num.length - 1] = r.nextInt(16) + 1;
return num;
}
private static void printArr(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("]");
}
}
分析：
- 定义一个方法，该方法可以录入用户输入的 6 个红球和 1 个蓝色号码
- 该方法最终返回一个数组，数组中就是用户录入的号码（7位）
private static int[] userInputNum() {
// 定义一个数组存储 7 个号码
int[] num = new int[7];
// 用户输入 7 个号码
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 6; i++) {
System.out.printf("请您输入第%d个红球号码：\n", i + 1);
int data = sc.nextInt();
// 把数据存入数组中
num[i] = data;
}
// 存入蓝球号码
System.out.println("请您输入蓝球号码：");
num[num.length - 1] = sc.nextInt();
return num;
}
private static void judge(int[] arr, int[] arrUser) {
// 判断是否中奖
int red = 0, blue = arr[arr.length - 1] == arrUser[arrUser.length - 1] ? 1 : 0;
// 统计红球的个数
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arrUser.length - 1; j++) {
if (arr[i] == arrUser[j]) {
red++;
break;
}
}
}
System.out.println("红球中奖个数：" + red + "\t蓝球中奖个数：" + blue);
}
package demo001;
import java.util.Random;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
int[] arr = createLuckNum(), userArr = userInputNum();
System.out.println("中奖号码：");
printArr(arr);
System.out.println("投注号码：");
printArr(userArr);
judge(arr, userArr);
}
private static int[] createLuckNum() {
// 定义一个动态初始化的数组，有 7 个数字
int[] num = new int[7];
Random r = new Random();
// 红球赋值
for (int i = 0; i < 6; i++) {
// 注意要判断数字是否出现过
while (true) {
int data = r.nextInt(33) + 1;
boolean flag = true; // 默认没有重复
for (int j = 0; j < i; j++) {
if (num[j] == data) {
flag = false;
break;
}
}
if (flag) {
// 没有重复
num[i] = data;
break;
}
}
}
// 生成蓝色号码
num[num.length - 1] = r.nextInt(16) + 1;
return num;
}
private static void printArr(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("]");
}
private static int[] userInputNum() {
// 定义一个数组存储 7 个号码
int[] num = new int[7];
// 用户输入 7 个号码
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 6; i++) {
System.out.printf("请您输入第%d个红球号码：\n", i + 1);
int data = sc.nextInt();
// 把数据存入数组中
num[i] = data;
}
// 存入蓝球号码
System.out.println("请您输入蓝球号码：");
num[num.length - 1] = sc.nextInt();
return num;
}
private static void judge(int[] arr, int[] arrUser) {
// 判断是否中奖
int red = 0, blue = arr[arr.length - 1] == arrUser[arrUser.length - 1] ? 1 : 0;
// 统计红球的个数
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arrUser.length - 1; j++) {
if (arr[i] == arrUser[j]) {
red++;
break;
}
}
}
System.out.println("红球中奖个数：" + red + "\t蓝球中奖个数：" + blue);
}
}