import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test1 {
public static void main(String[] args) throws IOException {
/*
制造假数据：
获取姓氏：https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0
获取男生名字：http://www.haoming8.cn/baobao/10881.html
获取女生名字：http://www.haoming8.cn/baobao/7641.html
*/
//1.定义变量记录网址
String familyNameNet = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0";
String boyNameNet = "http://www.haoming8.cn/baobao/10881.html";
String girlNameNet = "http://www.haoming8.cn/baobao/7641.html";
//2.爬取数据,把网址上所有的数据拼接成一个字符串
String familyNameStr = webCrawler(familyNameNet);
String boyNameStr = webCrawler(boyNameNet);
String girlNameStr = webCrawler(girlNameNet);
//3.通过正则表达式，把其中符合要求的数据获取出来
ArrayList familyNameTempList = getData(familyNameStr,"(.{4})(，|。)",1);
ArrayList boyNameTempList = getData(boyNameStr,"([\\u4E00-\\u9FA5]{2})(、|。)",1);
ArrayList girlNameTempList = getData(girlNameStr,"(.. ){4}..",0);
//4.处理数据
//familyNameTempList（姓氏）
//处理方案：把每一个姓氏拆开并添加到一个新的集合当中
ArrayList familyNameList = new ArrayList<>();
for (String str : familyNameTempList) {
//str 赵钱孙李 周吴郑王 冯陈褚卫 蒋沈韩杨
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
familyNameList.add(c + "");
}
}
//boyNameTempList（男生的名字）
//处理方案：去除其中的重复元素
ArrayList boyNameList = new ArrayList<>();
for (String str : boyNameTempList) {
if(!boyNameList.contains(str)){
boyNameList.add(str);
}
}
//girlNameTempList（女生的名字）
//处理方案：把里面的每一个元素用空格进行切割，得到每一个女生的名字
ArrayList girlNameList = new ArrayList<>();
for (String str : girlNameTempList) {
String[] arr = str.split(" ");
for (int i = 0; i < arr.length; i++) {
girlNameList.add(arr[i]);
}
}
//5.生成数据
//姓名（唯一）-性别-年龄
ArrayList list = getInfos(familyNameList, boyNameList, girlNameList, 70, 50);
Collections.shuffle(list);
//6.写出数据
BufferedWriter bw = new BufferedWriter(new FileWriter("myiotest\\names.txt"));
for (String str : list) {
bw.write(str);
bw.newLine();
}
bw.close();
}
/*
* 作用：
* 获取男生和女生的信息：张三-男-23
*
* 形参：
* 参数一：装着姓氏的集合
* 参数二：装着男生名字的集合
* 参数三：装着女生名字的集合
* 参数四：男生的个数
* 参数五：女生的个数
* */
public static ArrayList getInfos(ArrayList familyNameList,ArrayList boyNameList,ArrayList girlNameList, int boyCount,int girlCount){
//1.生成男生不重复的名字
HashSet boyhs = new HashSet<>();
while (true){
if(boyhs.size() == boyCount){
break;
}
//随机
Collections.shuffle(familyNameList);
Collections.shuffle(boyNameList);
boyhs.add(familyNameList.get(0) + boyNameList.get(0));
}
//2.生成女生不重复的名字
HashSet girlhs = new HashSet<>();
while (true){
if(girlhs.size() == girlCount){
break;
}
//随机
Collections.shuffle(familyNameList);
Collections.shuffle(girlNameList);
girlhs.add(familyNameList.get(0) + girlNameList.get(0));
}
//3.生成男生的信息并添加到集合当中
ArrayList list = new ArrayList<>();
Random r = new Random();
//【18 ~ 27】
for (String boyName : boyhs) {
//boyName依次表示每一个男生的名字
int age = r.nextInt(10) + 18;
list.add(boyName + "-男-" + age);
}
//4.生成女生的信息并添加到集合当中
//【18 ~ 25】
for (String girlName : girlhs) {
//girlName依次表示每一个女生的名字
int age = r.nextInt(8) + 18;
list.add(girlName + "-女-" + age);
}
return list;
}
/*
* 作用：根据正则表达式获取字符串中的数据
* 参数一：
* 完整的字符串
* 参数二：
* 正则表达式
* 参数三：
* 获取数据
* 0：获取符合正则表达式所有的内容
* 1：获取正则表达式中第一组数据
* 2：获取正则表达式中第二组数据
* ...以此类推
*
* 返回值：
* 真正想要的数据
*
* */
private static ArrayList getData(String str, String regex,int index) {
//1.创建集合存放数据
ArrayList list = new ArrayList<>();
//2.按照正则表达式的规则，去获取数据
Pattern pattern = Pattern.compile(regex);
//按照pattern的规则，到str当中获取数据
Matcher matcher = pattern.matcher(str);
while (matcher.find()){
list.add(matcher.group(index));
}
return list;
}
/*
* 作用：
* 从网络中爬取数据，把数据拼接成字符串返回
* 形参：
* 网址
* 返回值：
* 爬取到的所有数据
* */
public static String webCrawler(String net) throws IOException {
//1.定义StringBuilder拼接爬取到的数据
StringBuilder sb = new StringBuilder();
//2.创建一个URL对象
URL url = new URL(net);
//3.链接上这个网址
//细节：保证网络是畅通的，而且这个网址是可以链接上的。
URLConnection conn = url.openConnection();
//4.读取数据
InputStreamReader isr = new InputStreamReader(conn.getInputStream());
int ch;
while ((ch = isr.read()) != -1){
sb.append((char)ch);
}
//5.释放资源
isr.close();
//6.把读取到的数据返回
return sb.toString();
}
}
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.http.HttpUtil;
import java.util.*;
public class Test2 {
public static void main(String[] args){
//利用糊涂包生成假数据，并写到文件当中
//1. 定义网址
String familyNameNet = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0";
String boyNameNet = "http://www.haoming8.cn/baobao/10881.html";
String girlNameNet = "http://www.haoming8.cn/baobao/7641.html";
//2.爬取数据
String familyNameStr = HttpUtil.get(familyNameNet);
String boyNameStr = HttpUtil.get(boyNameNet);
String girlNameStr = HttpUtil.get(girlNameNet);
//3.利用正则表达式获取数据
//通过正则表达式，把其中符合要求的数据获取出来
List familyNameTempList = ReUtil.findAll("(.{4})(，|。)", familyNameStr, 1);
List boyNameTempList = ReUtil.findAll("([\\u4E00-\\u9FA5]{2})(、|。)", boyNameStr, 1);
List girlNameTempList = ReUtil.findAll("(.. ){4}..", girlNameStr, 0);
System.out.println(familyNameTempList);
System.out.println(boyNameTempList);
System.out.println(girlNameTempList);
//4.处理数据
//familyNameTempList（姓氏）
//处理方案：把每一个姓氏拆开并添加到一个新的集合当中
ArrayList familyNameList = new ArrayList<>();
for (String str : familyNameTempList) {
//str 赵钱孙李 周吴郑王 冯陈褚卫 蒋沈韩杨
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
familyNameList.add(c + "");
}
}
//boyNameTempList（男生的名字）
//处理方案：去除其中的重复元素
ArrayList boyNameList = new ArrayList<>();
for (String str : boyNameTempList) {
if(!boyNameList.contains(str)){
boyNameList.add(str);
}
}
//girlNameTempList（女生的名字）
//处理方案：把里面的每一个元素用空格进行切割，得到每一个女生的名字
ArrayList girlNameList = new ArrayList<>();
for (String str : girlNameTempList) {
String[] arr = str.split(" ");
for (int i = 0; i < arr.length; i++) {
girlNameList.add(arr[i]);
}
}
//5.生成数据
//姓名（唯一）-性别-年龄
ArrayList list = getInfos(familyNameList, boyNameList, girlNameList, 70, 50);
Collections.shuffle(list);
//6.写出数据
//细节：
//糊涂包的相对路径，不是相对于当前项目而言的，而是相对class文件而言的
FileUtil.writeLines(list,"D:\\names.txt","UTF-8");
}
/*
* 作用：
* 获取男生和女生的信息：张三-男-23
*
* 形参：
* 参数一：装着姓氏的集合
* 参数二：装着男生名字的集合
* 参数三：装着女生名字的集合
* 参数四：男生的个数
* 参数五：女生的个数
* */
public static ArrayList getInfos(ArrayList familyNameList,ArrayList boyNameList,ArrayList girlNameList, int boyCount,int girlCount){
//1.生成男生不重复的名字
HashSet boyhs = new HashSet<>();
while (true){
if(boyhs.size() == boyCount){
break;
}
//随机
Collections.shuffle(familyNameList);
Collections.shuffle(boyNameList);
boyhs.add(familyNameList.get(0) + boyNameList.get(0));
}
//2.生成女生不重复的名字
HashSet girlhs = new HashSet<>();
while (true){
if(girlhs.size() == girlCount){
break;
}
//随机
Collections.shuffle(familyNameList);
Collections.shuffle(girlNameList);
girlhs.add(familyNameList.get(0) + girlNameList.get(0));
}
//3.生成男生的信息并添加到集合当中
ArrayList list = new ArrayList<>();
Random r = new Random();
//【18 ~ 27】
for (String boyName : boyhs) {
//boyName依次表示每一个男生的名字
int age = r.nextInt(10) + 18;
list.add(boyName + "-男-" + age);
}
//4.生成女生的信息并添加到集合当中
//【18 ~ 25】
for (String girlName : girlhs) {
//girlName依次表示每一个女生的名字
int age = r.nextInt(8) + 18;
list.add(girlName + "-女-" + age);
}
return list;
}
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Test {
public static void main(String[] args) throws IOException {
/*需求：
需求：
有一个文件里面存储了班级同学的信息，每一个信息占一行。
格式为：张三-男-23
要求通过程序实现随机点名器。
运行效果：
第一次运行程序：随机同学姓名1（只显示名字）
第二次运行程序：随机同学姓名2（只显示名字）
第三次运行程序：随机同学姓名3（只显示名字）
…
*/
//1.读取文件中学生的姓名
ArrayList list = new ArrayList<>();
BufferedReader br = new BufferedReader(new FileReader("myiotest\\src\\com\\itheima\\myiotest2\\names.txt"));
String line;
while ((line = br.readLine()) != null){
list.add(line);
}
br.close();
//2.随机抽取(解法一)
Random r = new Random();
int index = r.nextInt(list.size());
String randomName1 = list.get(index);
String[] arr1 = randomName1.split("-");
System.out.println(arr1[0]);
//2.随机抽取(解法二)
Collections.shuffle(list);
String randomName2 = list.get(0);
String[] arr2 = randomName2.split("-");
System.out.println(arr2[0]);
}
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Test {
public static void main(String[] args) throws IOException {
/*需求：
一个文件里面存储了班级同学的信息，格式为：张三-男-23
每一个学生信息占一行。
要求通过程序实现随机点名器。
70%的概率随机到男生
30%的概率随机到女生
随机100万次，统计结果。看生成男生和女生的比例是不是接近于7：3
*/
//1.读取数据，并把男生和女生的信息添加到不同的集合当中
ArrayList boyNameList = new ArrayList<>();
ArrayList girlNameList = new ArrayList<>();
BufferedReader br = new BufferedReader(new FileReader("myiotest\\src\\com\\itheima\\myiotest3\\names.txt"));
String line;
while ((line = br.readLine()) != null){
String[] arr = line.split("-");
if(arr[1].equals("男")){
boyNameList.add(line);
}else{
girlNameList.add(line);
}
}
br.close();
//2.定义权重集合，男女比例：7:3
ArrayList list = new ArrayList<>();
Collections.addAll(list,1,1,1,1,1,1,1,0,0,0);
//3.定义变量，统计被点到的次数
int boyCount = 0;
int girlCount = 0;
Random r = new Random();
//4.循环100万次
for (int i = 0; i < 1000000; i++) {
//5.从权重集合中获取随机数据
int index = r.nextInt(list.size());
int weight = list.get(index);
//6.判断获取的随机数据是1还是0
if(weight == 1){
//1就随机男生
Collections.shuffle(boyNameList);
String boyInfo = boyNameList.get(0);
System.out.println(boyInfo);
boyCount++;
}else{
//0就随机女生
Collections.shuffle(girlNameList);
String girlInfo = girlNameList.get(0);
System.out.println(girlInfo);
girlCount++;
}
}
System.out.println("随机抽取100万次，其中男生被抽到了" + boyCount);
System.out.println("随机抽取100万次，其中女生被抽到了" + girlCount);
}
}
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
public class Test {
public static void main(String[] args) throws IOException {
/*需求：
一个文件里面存储了班级同学的姓名，每一个姓名占一行。
要求通过程序实现随机点名器。
第三次必定是张三同学
运行效果：
第一次运行程序：随机同学姓名1
第二次运行程序：随机同学姓名2
第三次运行程序：张三
…
*/
//1.读取数据，并把学生信息添加到集合当中
ArrayList list = new ArrayList<>();
BufferedReader br1 = new BufferedReader(new FileReader("myiotest\\src\\com\\itheima\\myiotest4\\names.txt"));
String line;
while ((line = br1.readLine()) != null){
list.add(line);
}
br1.close();
//2.读取当前程序已经运行的次数
BufferedReader br2 = new BufferedReader(new FileReader("myiotest\\src\\com\\itheima\\myiotest4\\count.txt"));
String countStr = br2.readLine();
int count = Integer.parseInt(countStr);
br2.close();
//4.表示程序再次运行了一次
count++;
//3.判断，如果当前已经是第三次，直接打印，不是第三次才随机
if(count == 3){
System.out.println("张三");
}else {
Collections.shuffle(list);
String stuInfo = list.get(0);
System.out.println(stuInfo);
}
//4.将程序已经运行的次数写会本地文件
BufferedWriter bw = new BufferedWriter(new FileWriter("myiotest\\src\\com\\itheima\\myiotest4\\count.txt"));
bw.write(count + "");
bw.close();
}
}
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
public class Test {
public static void main(String[] args) throws IOException {
/*需求：
一个文件里面存储了班级同学的姓名，每一个姓名占一行。
要求通过程序实现随机点名器。
运行结果要求：
被点到的学生不会再被点到。
但是如果班级中所有的学生都点完了， 需要重新开启第二轮点名。
核心思想：
点一个删一个，把删除的备份，全部点完时还原数据。
*/
//1.定义变量，表示初始文件路径，文件中存储所有的学生信息
String src = "myiotest\\src\\com\\itheima\\myiotest5\\names.txt";
//2.定义变量，表示备份文件，一开始文件为空
String backups = "myiotest\\src\\com\\itheima\\myiotest5\\backups.txt";
//3.读取初始文件中的数据，并把学生信息添加到集合当中
ArrayList list = readFile(src);
//4.判断集合中是否有数据
if (list.size() == 0) {
//5.如果没有数据，表示所有学生已经点完，从backups.txt中还原数据即可
//还原数据需要以下步骤：
//5.1 读取备份文件中所有的数据
list = readFile(backups);
//5.2 把所有的数据写到初始文件中
writeFile(src, list, false);
//5.3 删除备份文件
new File(backups).delete();
}
//5.集合中有数据，表示还没有点完，点一个删一个，把删除的备份到backups.txt当中
//打乱集合
Collections.shuffle(list);
//获取0索引的学生信息并删除
String stuInfo = list.remove(0);
//打印随机到的学生信息
System.out.println("当前被点到的学生为：" + stuInfo);
//把删除之后的所有学生信息，写到初始文件中
writeFile(src, list, false);
//把删除的学生信息备份（追加写入）
writeFile(backups, stuInfo, true);
}
private static void writeFile(String pathFile, ArrayList list, boolean isAppend) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter(pathFile, isAppend));
for (String str : list) {
bw.write(str);
bw.newLine();
}
bw.close();
}
private static void writeFile(String pathFile, String str, boolean isAppend) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter(pathFile, isAppend));
bw.write(str);
bw.newLine();
bw.close();
}
private static ArrayList readFile(String pathFile) throws IOException {
ArrayList list = new ArrayList<>();
BufferedReader br = new BufferedReader(new FileReader(pathFile));
String line;
while ((line = br.readLine()) != null) {
list.add(line);
}
br.close();
return list;
}
}
public class Student {
private String name;
private String gender;
private int age;
private double weight;
public Student() {
}
public Student(String name, String gender, int age, double weight) {
this.name = name;
this.gender = gender;
this.age = age;
this.weight = weight;
}
/**
* 获取
*
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
*
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
*
* @return gender
*/
public String getGender() {
return gender;
}
/**
* 设置
*
* @param gender
*/
public void setGender(String gender) {
this.gender = gender;
}
/**
* 获取
*
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
*
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
*
* @return weight
*/
public double getWeight() {
return weight;
}
/**
* 设置
*
* @param weight
*/
public void setWeight(double weight) {
this.weight = weight;
}
public String toString() {
return name + "-" + gender + "-" + age + "-" + weight;
}
}
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
public class Test {
public static void main(String[] args) throws IOException {
//1.把文件中所有的学生信息读取到内存中
ArrayList list = new ArrayList<>();
BufferedReader br = new BufferedReader(new FileReader("myiotest\\src\\com\\itheima\\myiotest6\\names.txt"));
String line;
while((line = br.readLine()) != null){
String[] arr = line.split("-");
Student stu = new Student(arr[0],arr[1],Integer.parseInt(arr[2]),Double.parseDouble(arr[3]));
list.add(stu);
}
br.close();
//2.计算权重的总和
double weight = 0;
for (Student stu : list) {
weight = weight + stu.getWeight();
}
//3.计算每一个人的实际占比
//[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]
double[] arr = new double[list.size()];
int index = 0;
for (Student stu : list) {
arr[index] = stu.getWeight() / weight;
index++;
}
//4.计算每一个人的权重占比范围
for (int i = 1; i < arr.length; i++) {
arr[i] = arr[i] + arr[i - 1];
}
//5.随机抽取
//获取一个0.0~1.0之间的随机数
double number = Math.random();
//判断number在arr中的位置
//二分查找法
//方法回返回： - 插入点 - 1
//获取number这个数据在数组当中的插入点位置
int result = -Arrays.binarySearch(arr, number) - 1;
Student stu = list.get(result);
System.out.println(stu);
//6.修改当前学生的权重
double w = stu.getWeight() / 2;
stu.setWeight(w);
//7.把集合中的数据再次写到文件中
BufferedWriter bw = new BufferedWriter(new FileWriter("myiotest\\src\\com\\itheima\\myiotest6\\names.txt"));
for (Student s : list) {
bw.write(s.toString());
bw.newLine();
}
bw.close();
}
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
public class Test {
public static void main(String[] args) throws IOException {
/*
需求：写一个登陆小案例。
步骤：
将正确的用户名和密码手动保存在本地的userinfo.txt文件中。
保存格式为:username=zhangsan&password=123
让用户键盘录入用户名和密码
比较用户录入的和正确的用户名密码是否一致
如果一致则打印登陆成功
如果不一致则打印登陆失败
*/
//1.读取正确的用户名和密码
BufferedReader br = new BufferedReader(new FileReader("myiotest\\src\\com\\itheima\\myiotest7\\userinfo.txt"));
String line = br.readLine();//username=zhangsan&password=123
br.close();
String[] userInfo = line.split("&");
String[] arr1 = userInfo[0].split("=");
String[] arr2 = userInfo[1].split("=");
String rightUsername = arr1[1];
String rightPassword = arr2[1];
//2.用户键盘录入用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.nextLine();
System.out.println("请输入密码");
String password = sc.nextLine();
//3.比较
if(rightUsername.equals(username) && rightPassword.equals(password)){
System.out.println("登陆成功");
}else{
System.out.println("登陆失败");
}
}
}
import java.io.*;
import java.util.Scanner;
public class Test {
public static void main(String[] args) throws IOException {
/*
需求：写一个登陆小案例（添加锁定账号功能）
步骤：
将正确的用户名和密码手动保存在本地的userinfo.txt文件中。
保存格式为:username=zhangsan&password=123&count=0
让用户键盘录入用户名和密码
比较用户录入的和正确的用户名密码是否一致
如果一致则打印登陆成功
如果不一致则打印登陆失败，连续输错三次被锁定
*/
//1.读取正确的用户名和密码
BufferedReader br = new BufferedReader(new FileReader("myiotest\\src\\com\\itheima\\myiotest8\\userinfo.txt"));
String line = br.readLine();//username=zhangsan&password=123&count=0
br.close();
String[] userInfo = line.split("&");
String[] arr1 = userInfo[0].split("=");
String[] arr2 = userInfo[1].split("=");
String[] arr3 = userInfo[2].split("=");
String rightUsername = arr1[1];
String rightPassword = arr2[1];
//count:表示用户连续输错的次数
int count = Integer.parseInt(arr3[1]);
//2.用户键盘录入用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.nextLine();
System.out.println("请输入密码");
String password = sc.nextLine();
//3.比较
if (rightUsername.equals(username) && rightPassword.equals(password) && count < 3) {
System.out.println("登陆成功");
writeInfo("username=" + rightUsername + "&password=" + rightPassword + "&count=0");
} else {
count++;
if (count < 3) {
System.out.println("登陆失败,还剩下" + (3 - count) + "次机会");
} else {
System.out.println("用户账户被锁定");
}
writeInfo("username=" + rightUsername + "&password=" + rightPassword + "&count=" + count);
}
}
/*
* 作用：
* 写出一个字符串到本地文件中
* 参数：
* 要写出的字符串
* */
public static void writeInfo(String content) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter("myiotest\\src\\com\\itheima\\myiotest8\\userinfo.txt"));
bw.write(content);
bw.close();
}
}
import java.util.Properties;
public class Test1 {
public static void main(String[] args) {
/*
Properties作为Map集合的操作
*/
//1.创建集合的对象
Properties prop = new Properties();
//2.添加数据
//细节：虽然我们可以往Properties当中添加任意的数据类型，但是一般只会往里面添加字符串类型的数据
prop.put("aaa","111");
prop.put("bbb","222");
prop.put("ccc","333");
prop.put("ddd","444");
//3.遍历集合
/*Set尖括号Object> keys = prop.keySet();
for (Object key : keys) {
Object value = prop.get(key);
System.out.println(key + "=" + value);
}*/
/* Set 尖括号 Map.Entry尖括号Object, Object两个大括号 entries = prop.entrySet();
for (Map.Entry 尖括号 Object, Object 尖括号 entry : entries) {
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + "=" + value);
}*/
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
public class Test2 {
public static void main(String[] args) throws IOException {
/*
Properties跟IO流结合的操作
*/
//1.创建集合
Properties prop = new Properties();
//2.添加数据
prop.put("aaa","bbb");
prop.put("bbb","ccc");
prop.put("ddd","eee");
prop.put("fff","iii");
//3.把集合中的数据以键值对的形式写到本地文件当中
FileOutputStream fos = new FileOutputStream("myiotest\\a.properties");
prop.store(fos,"test");
fos.close();
/*BufferedWriter bw = new BufferedWriter(new FileWriter("myiotest\\a.properties"));
Set尖括号Map.Entry尖括号Object, Object尖括号 entries = prop.entrySet();
for (Map.Entry尖括号Object, Object> entry : entries) {
Object key = entry.getKey();
Object value = entry.getValue();
bw.write(key + "=" + value);
bw.newLine();
}
bw.close();*/
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class Test3 {
public static void main(String[] args) throws IOException {
//1.创建集合
Properties prop = new Properties();
//2.读取本地Properties文件里面的数据
FileInputStream fis = new FileInputStream("myiotest\\a.properties");
prop.load(fis);
fis.close();
//3.打印集合
System.out.println(prop);
}
}
import java.io.Serial;
import java.io.Serializable;
public class GameInfo implements Serializable {
@Serial
private static final long serialVersionUID = 5544981119935263973L;
private int[][] data;
private int x = 0;
private int y = 0;
private String path;
private int step;
public GameInfo() {
}
public GameInfo(int[][] data, int x, int y, String path, int step) {
this.data = data;
this.x = x;
this.y = y;
this.path = path;
this.step = step;
}
/**
* 获取
* @return data
*/
public int[][] getData() {
return data;
}
/**
* 设置
* @param data
*/
public void setData(int[][] data) {
this.data = data;
}
/**
* 获取
* @return x
*/
public int getX() {
return x;
}
/**
* 设置
* @param x
*/
public void setX(int x) {
this.x = x;
}
/**
* 获取
* @return y
*/
public int getY() {
return y;
}
/**
* 设置
* @param y
*/
public void setY(int y) {
this.y = y;
}
/**
* 获取
* @return path
*/
public String getPath() {
return path;
}
/**
* 设置
* @param path
*/
public void setPath(String path) {
this.path = path;
}
/**
* 获取
* @return step
*/
public int getStep() {
return step;
}
/**
* 设置
* @param step
*/
public void setStep(int step) {
this.step = step;
}
public String toString() {
return "GameInfo{data = " + data + ", x = " + x + ", y = " + y + ", path = " + path + ", step = " + step + "}";
}
}
public class User {
private String username;
private String password;
public User() {
}
public User(String username, String password) {
this.username = username;
this.password = password;
}
/**
* 获取
*
* @return username
*/
public String getUsername() {
return username;
}
/**
* 设置
*
* @param username
*/
public void setUsername(String username) {
this.username = username;
}
/**
* 获取
*
* @return password
*/
public String getPassword() {
return password;
}
/**
* 设置
*
* @param password
*/
public void setPassword(String password) {
this.password = password;
}
public String toString() {
return "username=" + username + "&password=" + password;
}
}
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class MyActionListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("按钮被点击了");
}
}
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
public class MyJFrame extends JFrame implements ActionListener {
//创建一个按钮对象
JButton jtb1 = new JButton("点我啊");
//创建一个按钮对象
JButton jtb2 = new JButton("再点我啊");
public MyJFrame(){
//设置界面的宽高
this.setSize(603, 680);
//设置界面的标题
this.setTitle("拼图单机版 v1.0");
//设置界面置顶
this.setAlwaysOnTop(true);
//设置界面居中
this.setLocationRelativeTo(null);
//设置关闭模式
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//取消默认的居中放置，只有取消了才会按照XY轴的形式添加组件
this.setLayout(null);
//给按钮设置位置和宽高
jtb1.setBounds(0,0,100,50);
//给按钮添加事件
jtb1.addActionListener(this);
//给按钮设置位置和宽高
jtb2.setBounds(100,0,100,50);
jtb2.addActionListener(this);
//那按钮添加到整个界面当中
this.getContentPane().add(jtb1);
this.getContentPane().add(jtb2);
//让整个界面显示出来
this.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
//对当前的按钮进行判断
//获取当前被操作的那个按钮对象
Object source = e.getSource();
if(source == jtb1){
jtb1.setSize(200,200);
}else if(source == jtb2){
Random r = new Random();
jtb2.setLocation(r.nextInt(500),r.nextInt(500));
}
}
}
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.Random;
public class MyJFrame2 extends JFrame implements MouseListener {
//创建一个按钮对象
JButton jtb1 = new JButton("点我啊");
public MyJFrame2(){
//设置界面的宽高
this.setSize(603, 680);
//设置界面的标题
this.setTitle("拼图单机版 v1.0");
//设置界面置顶
this.setAlwaysOnTop(true);
//设置界面居中
this.setLocationRelativeTo(null);
//设置关闭模式
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//取消默认的居中放置，只有取消了才会按照XY轴的形式添加组件
this.setLayout(null);
//给按钮设置位置和宽高
jtb1.setBounds(0,0,100,50);
//给按钮绑定鼠标事件
jtb1.addMouseListener(this);
//那按钮添加到整个界面当中
this.getContentPane().add(jtb1);
//让整个界面显示出来
this.setVisible(true);
}
@Override
public void mouseClicked(MouseEvent e) {
System.out.println("单击");
}
@Override
public void mousePressed(MouseEvent e) {
System.out.println("按下不松");
}
@Override
public void mouseReleased(MouseEvent e) {
System.out.println("松开");
}
@Override
public void mouseEntered(MouseEvent e) {
System.out.println("划入");
}
@Override
public void mouseExited(MouseEvent e) {
System.out.println("划出");
}
}
import javax.swing.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.security.Key;
public class MyJFrame3 extends JFrame implements KeyListener {
public MyJFrame3(){
//设置界面的宽高
this.setSize(603, 680);
//设置界面的标题
this.setTitle("拼图单机版 v1.0");
//设置界面置顶
this.setAlwaysOnTop(true);
//设置界面居中
this.setLocationRelativeTo(null);
//设置关闭模式
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//取消默认的居中放置，只有取消了才会按照XY轴的形式添加组件
this.setLayout(null);
//给整个窗体添加键盘监听
//调用者this：本类对象，当前的界面对象，表示我要给整个界面添加监听
//addKeyListener：表示要给本界面添加键盘监听
//参数this：当事件被触发之后，会执行本类中的对应代码
this.addKeyListener(this);
//让整个界面显示出来
this.setVisible(true);
}
@Override
public void keyTyped(KeyEvent e) {
}
//细节1：
//如果我们按下一个按键没有松开，那么会重复的去调用keyPressed方法
//细节2：
//键盘里面那么多按键，如何进行区分?
//每一个按键都有一个编号与之对应
@Override
public void keyPressed(KeyEvent e) {
System.out.println("按下不松");
}
@Override
public void keyReleased(KeyEvent e) {
System.out.println("松开按键");
//获取键盘上每一个按键的编号
int code = e.getKeyCode();
if(code == 65){
System.out.println("现在按的是A");
}else if(code == 66){
System.out.println("现在按的是B");
}
}
}
import java.util.Random;
public class Test1 {
public static void main(String[] args) {
//需求：
//把一个一维数组中的数据：0~15 打乱顺序
//然后再按照4个一组的方式添加到二维数组当中
//1.定义一个一维数组
int[] tempArr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
//2.打乱数组中的数据的顺序
//遍历数组，得到每一个元素，拿着每一个元素跟随机索引上的数据进行交换
Random r = new Random();
for (int i = 0; i < tempArr.length; i++) {
//获取到随机索引
int index = r.nextInt(tempArr.length);
//拿着遍历到的每一个数据，跟随机索引上的数据进行交换
int temp = tempArr[i];
tempArr[i] = tempArr[index];
tempArr[index] = temp;
}
//3.遍历数组
for (int i = 0; i < tempArr.length; i++) {
System.out.print(tempArr[i] + " ");
}
System.out.println();
//4.创建一个二维数组
int[][] data = new int[4][4];
//5.给二维数组添加数据
//解法一：
//遍历一维数组tempArr得到每一个元素，把每一个元素依次添加到二维数组当中
for (int i = 0; i < tempArr.length; i++) {
data[i / 4][i % 4] = tempArr[i];
}
//遍历二维数组
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
System.out.print(data[i][j] + " ");
}
System.out.println();
}
}
}
import java.util.Random;
public class Test2 {
public static void main(String[] args) {
//需求：
//把一个一维数组中的数据：0~15 打乱顺序
//然后再按照4个一组的方式添加到二维数组当中
//1.定义一个一维数组
int[] tempArr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
//2.打乱数组中的数据的顺序
//遍历数组，得到每一个元素，拿着每一个元素跟随机索引上的数据进行交换
Random r = new Random();
for (int i = 0; i < tempArr.length; i++) {
//获取到随机索引
int index = r.nextInt(tempArr.length);
//拿着遍历到的每一个数据，跟随机索引上的数据进行交换
int temp = tempArr[i];
tempArr[i] = tempArr[index];
tempArr[index] = temp;
}
//3.遍历数组
for (int i = 0; i < tempArr.length; i++) {
System.out.print(tempArr[i] + " ");
}
System.out.println();
//4.创建一个二维数组
int[][] data = new int[4][4];
//5.给二维数组添加数据
//解法二：
//遍历二维数组，给里面的每一个数据赋值
int index = 0;
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
data[i][j] = tempArr[index];
index++;
}
}
//遍历二维数组
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
System.out.print(data[i][j] + " ");
}
System.out.println();
}
}
}
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Test3 {
public static void main(String[] args) {
JFrame jFrame = new JFrame();
//设置界面的宽高
jFrame.setSize(603, 680);
//设置界面的标题
jFrame.setTitle("事件演示");
//设置界面置顶
jFrame.setAlwaysOnTop(true);
//设置界面居中
jFrame.setLocationRelativeTo(null);
//设置关闭模式
jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//取消默认的居中放置，只有取消了才会按照XY轴的形式添加组件
jFrame.setLayout(null);
//创建一个按钮对象
JButton jtb = new JButton("点我啊");
//设置位置和宽高
jtb.setBounds(0,0,100,50);
//给按钮添加动作监听
//jtb:组件对象，表示你要给哪个组件添加事件
//addActionListener：表示我要给组件添加哪个事件监听（动作监听包含鼠标左键点击，空格）
//参数：表示事件被触发之后要执行的代码
//jtb.addActionListener(new MyActionListener());
jtb.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("达咩~不要点我哟~");
}
});
//把按钮添加到界面当中
jFrame.getContentPane().add(jtb);
jFrame.setVisible(true);
}
}
public class Test4 {
public static void main(String[] args) {
new MyJFrame3();
}
}
import cn.hutool.core.io.IoUtil;
import com.itheima.domain.GameInfo;
import javax.swing.*;
import javax.swing.border.BevelBorder;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.*;
import java.util.Random;
public class GameJFrame extends JFrame implements KeyListener, ActionListener {
//JFrame 界面，窗体
//子类呢？也表示界面，窗体
//规定：GameJFrame这个界面表示的就是游戏的主界面
//以后跟游戏相关的所有逻辑都写在这个类中
//创建一个二维数组
//目的：用来管理数据
//加载图片的时候，会根据二维数组中的数据进行加载
int[][] data = new int[4][4];
//记录空白方块在二维数组中的位置
int x = 0;
int y = 0;
//定义一个变量，记录当前展示图片的路径
String path = "puzzlegame\\image\\animal\\animal3\\";
//定义一个二维数组，存储正确的数据
int[][] win = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 0}
};
//定义变量用来统计步数
int step = 0;
//创建选项下面的条目对象
JMenuItem girl = new JMenuItem("美女");
JMenuItem animal = new JMenuItem("动物");
JMenuItem sport = new JMenuItem("运动");
JMenuItem replayItem = new JMenuItem("重新游戏");
JMenuItem reLoginItem = new JMenuItem("重新登录");
JMenuItem closeItem = new JMenuItem("关闭游戏");
JMenu saveJMenu = new JMenu("存档");
JMenu loadJMenu = new JMenu("读档");
JMenuItem saveItem0 = new JMenuItem("存档0(空)");
JMenuItem saveItem1 = new JMenuItem("存档1(空)");
JMenuItem saveItem2 = new JMenuItem("存档2(空)");
JMenuItem saveItem3 = new JMenuItem("存档3(空)");
JMenuItem saveItem4 = new JMenuItem("存档4(空)");
JMenuItem loadItem0 = new JMenuItem("读档0(空)");
JMenuItem loadItem1 = new JMenuItem("读档1(空)");
JMenuItem loadItem2 = new JMenuItem("读档2(空)");
JMenuItem loadItem3 = new JMenuItem("读档3(空)");
JMenuItem loadItem4 = new JMenuItem("读档4(空)");
JMenuItem accountItem = new JMenuItem("公众号");
//创建随机对象
Random r = new Random();
public GameJFrame() {
//初始化界面
initJFrame();
//初始化菜单
initJMenuBar();
//初始化数据（打乱）
initData();
//初始化图片（根据打乱之后的结果去加载图片）
initImage();
//让界面显示出来，建议写在最后
this.setVisible(true);
}
//初始化数据（打乱）
private void initData() {
//1.定义一个一维数组
int[] tempArr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
//2.打乱数组中的数据的顺序
//遍历数组，得到每一个元素，拿着每一个元素跟随机索引上的数据进行交换
Random r = new Random();
for (int i = 0; i < tempArr.length; i++) {
//获取到随机索引
int index = r.nextInt(tempArr.length);
//拿着遍历到的每一个数据，跟随机索引上的数据进行交换
int temp = tempArr[i];
tempArr[i] = tempArr[index];
tempArr[index] = temp;
}
/*
*
* 5 6 8 9
* 10 11 15 1
* 4 7 12 13
* 2 3 0 14
*
* 5 6 8 9 10 11 15 1 4 7 12 13 2 3 0 14
* */
//4.给二维数组添加数据
//遍历一维数组tempArr得到每一个元素，把每一个元素依次添加到二维数组当中
for (int i = 0; i < tempArr.length; i++) {
if (tempArr[i] == 0) {
x = i / 4;
y = i % 4;
}
data[i / 4][i % 4] = tempArr[i];
}
}
//初始化图片
//添加图片的时候，就需要按照二维数组中管理的数据添加图片
private void initImage() {
//清空原本已经出现的所有图片
this.getContentPane().removeAll();
if (victory()) {
//显示胜利的图标
JLabel winJLabel = new JLabel(new ImageIcon("C:\\Users\\moon\\IdeaProjects\\basic-code\\puzzlegame\\image\\win.png"));
winJLabel.setBounds(203, 283, 197, 73);
this.getContentPane().add(winJLabel);
}
JLabel stepCount = new JLabel("步数：" + step);
stepCount.setBounds(50, 30, 100, 20);
this.getContentPane().add(stepCount);
//路径分为两种：
//绝对路径：一定是从盘符开始的。C:\ D：\
//相对路径：不是从盘符开始的
//相对路径相对当前项目而言的。 aaa\\bbb
//在当前项目下，去找aaa文件夹，里面再找bbb文件夹。
//细节：
//先加载的图片在上方，后加载的图片塞在下面。
//外循环 --- 把内循环重复执行了4次。
for (int i = 0; i < 4; i++) {
//内循环 --- 表示在一行添加4张图片
for (int j = 0; j < 4; j++) {
//获取当前要加载图片的序号
int num = data[i][j];
//创建一个JLabel的对象（管理容器）
JLabel jLabel = new JLabel(new ImageIcon(path + num + ".jpg"));
//指定图片位置
jLabel.setBounds(105 * j + 83, 105 * i + 134, 105, 105);
//给图片添加边框
//0:表示让图片凸起来
//1：表示让图片凹下去
jLabel.setBorder(new BevelBorder(BevelBorder.LOWERED));
//把管理容器添加到界面中
this.getContentPane().add(jLabel);
}
}
//添加背景图片
JLabel background = new JLabel(new ImageIcon("puzzlegame\\image\\background.png"));
background.setBounds(40, 40, 508, 560);
//把背景图片添加到界面当中
this.getContentPane().add(background);
//刷新一下界面
this.getContentPane().repaint();
}
private void initJMenuBar() {
//创建整个的菜单对象
JMenuBar jMenuBar = new JMenuBar();
//创建菜单上面的两个选项的对象 （功能 关于我们）
JMenu functionJMenu = new JMenu("功能");
JMenu aboutJMenu = new JMenu("关于我们");
JMenu changeImage = new JMenu("更换图片");
//把5个存档，添加到saveJMenu中
saveJMenu.add(saveItem0);
saveJMenu.add(saveItem1);
saveJMenu.add(saveItem2);
saveJMenu.add(saveItem3);
saveJMenu.add(saveItem4);
//把5个读档，添加到loadJMenu中
loadJMenu.add(loadItem0);
loadJMenu.add(loadItem1);
loadJMenu.add(loadItem2);
loadJMenu.add(loadItem3);
loadJMenu.add(loadItem4);
//把美女，动物，运动添加到更换图片当中
changeImage.add(girl);
changeImage.add(animal);
changeImage.add(sport);
//将更换图片，重新游戏，重新登录，关闭游戏，存档，读档添加到“功能”选项当中
functionJMenu.add(changeImage);
functionJMenu.add(replayItem);
functionJMenu.add(reLoginItem);
functionJMenu.add(closeItem);
functionJMenu.add(saveJMenu);
functionJMenu.add(loadJMenu);
//将公众号添加到关于我们当中
aboutJMenu.add(accountItem);
//绑定点击事件
girl.addActionListener(this);
animal.addActionListener(this);
sport.addActionListener(this);
replayItem.addActionListener(this);
reLoginItem.addActionListener(this);
closeItem.addActionListener(this);
accountItem.addActionListener(this);
saveItem0.addActionListener(this);
saveItem1.addActionListener(this);
saveItem2.addActionListener(this);
saveItem3.addActionListener(this);
saveItem4.addActionListener(this);
loadItem0.addActionListener(this);
loadItem1.addActionListener(this);
loadItem2.addActionListener(this);
loadItem3.addActionListener(this);
loadItem4.addActionListener(this);
//将菜单里面的两个选项添加到菜单当中
jMenuBar.add(functionJMenu);
jMenuBar.add(aboutJMenu);
//读取存档信息，修改菜单上表示的内容
getGameInfo();
//给整个界面设置菜单
this.setJMenuBar(jMenuBar);
}
public void getGameInfo(){
//1.创建File对象表示所有存档所在的文件夹
File file = new File("puzzlegame\\save");
//2.进入文件夹获取到里面所有的存档文件
File[] files = file.listFiles();
//3.遍历数组，得到每一个存档
for (File f : files) {
//f ：依次表示每一个存档文件
//获取每一个存档文件中的步数
GameInfo gi = null;
try {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));
gi = (GameInfo)ois.readObject();
ois.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//获取到了步数
int step = gi.getStep();
//把存档的步数同步到菜单当中
//save0 ---> 0
//save1 ---> 1
//...
//获取存档的文件名 save0.data
String name = f.getName();
//获取当存档的序号（索引）
int index = name.charAt(4) - '0';
//修改菜单上所表示的文字信息
saveJMenu.getItem(index).setText("存档" + index + "(" + step + ")步");
loadJMenu.getItem(index).setText("存档" + index + "(" + step + ")步");
}
}
private void initJFrame() {
//设置界面的宽高
this.setSize(603, 680);
//设置界面的标题
this.setTitle("拼图单机版 v1.0");
//设置界面置顶
this.setAlwaysOnTop(true);
//设置界面居中
this.setLocationRelativeTo(null);
//设置关闭模式
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//取消默认的居中放置，只有取消了才会按照XY轴的形式添加组件
this.setLayout(null);
//给整个界面添加键盘监听事件
this.addKeyListener(this);
}
@Override
public void keyTyped(KeyEvent e) {
}
//按下不松时会调用这个方法
@Override
public void keyPressed(KeyEvent e) {
int code = e.getKeyCode();
if (code == 65) {
//把界面中所有的图片全部删除
this.getContentPane().removeAll();
//加载第一张完整的图片
JLabel all = new JLabel(new ImageIcon(path + "all.jpg"));
all.setBounds(83, 134, 420, 420);
this.getContentPane().add(all);
//加载背景图片
//添加背景图片
JLabel background = new JLabel(new ImageIcon("puzzlegame\\image\\background.png"));
background.setBounds(40, 40, 508, 560);
//把背景图片添加到界面当中
this.getContentPane().add(background);
//刷新界面
this.getContentPane().repaint();
}
}
//松开按键的时候会调用这个方法
@Override
public void keyReleased(KeyEvent e) {
//判断游戏是否胜利，如果胜利，此方法需要直接结束，不能再执行下面的移动代码了
if (victory()) {
//结束方法
return;
}
//对上，下，左，右进行判断
//左：37 上：38 右：39 下：40
int code = e.getKeyCode();
System.out.println(code);
if (code == 37) {
System.out.println("向左移动");
if (y == 3) {
return;
}
//逻辑：
//把空白方块右方的数字往左移动
data[x][y] = data[x][y + 1];
data[x][y + 1] = 0;
y++;
//每移动一次，计数器就自增一次。
step++;
//调用方法按照最新的数字加载图片
initImage();
} else if (code == 38) {
System.out.println("向上移动");
if (x == 3) {
//表示空白方块已经在最下方了，他的下面没有图片再能移动了
return;
}
//逻辑：
//把空白方块下方的数字往上移动
//x，y 表示空白方块
//x + 1， y 表示空白方块下方的数字
//把空白方块下方的数字赋值给空白方块
data[x][y] = data[x + 1][y];
data[x + 1][y] = 0;
x++;
//每移动一次，计数器就自增一次。
step++;
//调用方法按照最新的数字加载图片
initImage();
} else if (code == 39) {
System.out.println("向右移动");
if (y == 0) {
return;
}
//逻辑：
//把空白方块左方的数字往右移动
data[x][y] = data[x][y - 1];
data[x][y - 1] = 0;
y--;
//每移动一次，计数器就自增一次。
step++;
//调用方法按照最新的数字加载图片
initImage();
} else if (code == 40) {
System.out.println("向下移动");
if (x == 0) {
return;
}
//逻辑：
//把空白方块上方的数字往下移动
data[x][y] = data[x - 1][y];
data[x - 1][y] = 0;
x--;
//每移动一次，计数器就自增一次。
step++;
//调用方法按照最新的数字加载图片
initImage();
} else if (code == 65) {
initImage();
} else if (code == 87) {
data = new int[][]{
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 0}
};
initImage();
}
}
//判断data数组中的数据是否跟win数组中相同
//如果全部相同，返回true。否则返回false
public boolean victory() {
for (int i = 0; i < data.length; i++) {
//i : 依次表示二维数组 data里面的索引
//data[i]：依次表示每一个一维数组
for (int j = 0; j < data[i].length; j++) {
if (data[i][j] != win[i][j]) {
//只要有一个数据不一样，则返回false
return false;
}
}
}
//循环结束表示数组遍历比较完毕，全都一样返回true
return true;
}
@Override
public void actionPerformed(ActionEvent e) {
//获取当前被点击的条目对象
Object obj = e.getSource();
//判断
if (obj == replayItem) {
System.out.println("重新游戏");
//计步器清零
step = 0;
//再次打乱二维数组中的数据
initData();
//重新加载图片
initImage();
} else if (obj == reLoginItem) {
System.out.println("重新登录");
//关闭当前的游戏界面
this.setVisible(false);
//打开登录界面
new LoginJFrame();
} else if (obj == closeItem) {
System.out.println("关闭游戏");
//直接关闭虚拟机即可
System.exit(0);
} else if (obj == accountItem) {
System.out.println("公众号");
//创建一个弹框对象
JDialog jDialog = new JDialog();
//创建一个管理图片的容器对象JLabel
JLabel jLabel = new JLabel(new ImageIcon("puzzlegame\\image\\about.png"));
//设置位置和宽高
jLabel.setBounds(0, 0, 258, 258);
//把图片添加到弹框当中
jDialog.getContentPane().add(jLabel);
//给弹框设置大小
jDialog.setSize(344, 344);
//让弹框置顶
jDialog.setAlwaysOnTop(true);
//让弹框居中
jDialog.setLocationRelativeTo(null);
//弹框不关闭则无法操作下面的界面
jDialog.setModal(true);
//让弹框显示出来
jDialog.setVisible(true);
} else if (obj == girl) {
System.out.println("girl");
//下列代码重复了，自己思考一下，能否抽取成一个方法呢？
int number = r.nextInt(13) + 1;
path = "puzzlegame\\image\\girl\\girl" + number + "\\";
//计步器清零
step = 0;
//再次打乱二维数组中的数据
initData();
//重新加载图片
initImage();
} else if (obj == animal) {
System.out.println("animal");
//下列代码重复了，自己思考一下，能否抽取成一个方法呢？
int number = r.nextInt(8) + 1;
path = "puzzlegame\\image\\girl\\girl" + number + "\\";
//计步器清零
step = 0;
//再次打乱二维数组中的数据
initData();
//重新加载图片
initImage();
} else if (obj == sport) {
System.out.println("sport");
//下列代码重复了，自己思考一下，能否抽取成一个方法呢？
int number = r.nextInt(10) + 1;
path = "puzzlegame\\image\\girl\\girl" + number + "\\";
//计步器清零
step = 0;
//再次打乱二维数组中的数据
initData();
//重新加载图片
initImage();
} else if (obj == saveItem0 || obj == saveItem1 || obj == saveItem2 || obj == saveItem3 || obj == saveItem4) {
//获取当前是哪个存档被点击了，获取其中的序号
JMenuItem item = (JMenuItem) obj;
String str = item.getText();
int index = str.charAt(2) - '0';
//直接把游戏的数据写到本地文件中
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("puzzlegame\\save\\save" + index + ".data"));
GameInfo gi = new GameInfo(data, x, y, path, step);
IoUtil.writeObj(oos, true, gi);
} catch (IOException ioException) {
ioException.printStackTrace();
}
//修改一下存档item上的展示信息
//存档0(XX步)
item.setText("存档" + index + "(" + step + "步)");
//修改一下读档item上的展示信息
loadJMenu.getItem(index).setText("存档" + index + "(" + step + "步)");
} else if (obj == loadItem0 || obj == loadItem1 || obj == loadItem2 || obj == loadItem3 || obj == loadItem4) {
//获取当前是哪个读档被点击了，获取其中的序号
JMenuItem item = (JMenuItem) obj;
String str = item.getText();
int index = str.charAt(2) - '0';
GameInfo gi = null;
try {
//可以到本地文件中读取数据
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("puzzlegame\\save\\save" + index + ".data"));
gi = (GameInfo)ois.readObject();
ois.close();
} catch (IOException ioException) {
ioException.printStackTrace();
} catch (ClassNotFoundException classNotFoundException) {
classNotFoundException.printStackTrace();
}
data = gi.getData();
path = gi.getPath();
step = gi.getStep();
x = gi.getX();
y = gi.getY();
//重新刷新界面加载游戏
initImage();
}
}
}
import cn.hutool.core.io.FileUtil;
import com.itheima.domain.User;
import com.itheima.util.CodeUtil;
import javax.swing.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import java.util.List;
public class LoginJFrame extends JFrame implements MouseListener {
ArrayList allUsers = new ArrayList<>();
JButton login = new JButton();
JButton register = new JButton();
JTextField username = new JTextField();
//JTextField password = new JTextField();
JPasswordField password = new JPasswordField();
JTextField code = new JTextField();
//正确的验证码
JLabel rightCode = new JLabel();
public LoginJFrame() {
//读取本地文件中的用户信息
readUserInfo();
//初始化界面
initJFrame();
//在这个界面中添加内容
initView();
//让当前界面显示出来
this.setVisible(true);
}
//读取本地文件中的用户信息
private void readUserInfo() {
//1.读取数据
List userInfoStrList = FileUtil.readUtf8Lines("C:\\Users\\alienware\\IdeaProjects\\basic-code\\puzzlegame\\userinfo.txt");
//2.遍历集合获取用户信息并创建User对象
for (String str : userInfoStrList) {
//username=zhangsan&password=123
String[] userInfoArr = str.split("&");
//0 username=zhangsan 1 password=123
String[] arr1 = userInfoArr[0].split("=");
String[] arr2 = userInfoArr[1].split("=");
User u = new User(arr1[1],arr2[1]);
allUsers.add(u);
}
System.out.println(allUsers);
}
//点击
@Override
public void mouseClicked(MouseEvent e) {
if (e.getSource() == login) {
System.out.println("点击了登录按钮");
//获取两个文本输入框中的内容
String usernameInput = username.getText();
String passwordInput = password.getText();
//获取用户输入的验证码
String codeInput = code.getText();
//创建一个User对象
User userInfo = new User(usernameInput, passwordInput);
System.out.println("用户输入的用户名为" + usernameInput);
System.out.println("用户输入的密码为" + passwordInput);
if (codeInput.length() == 0) {
showJDialog("验证码不能为空");
} else if (usernameInput.length() == 0 || passwordInput.length() == 0) {
//校验用户名和密码是否为空
System.out.println("用户名或者密码为空");
//调用showJDialog方法并展示弹框
showJDialog("用户名或者密码为空");
} else if (!codeInput.equalsIgnoreCase(rightCode.getText())) {
showJDialog("验证码输入错误");
} else if (contains(userInfo)) {
System.out.println("用户名和密码正确可以开始玩游戏了");
//关闭当前登录界面
this.setVisible(false);
//打开游戏的主界面
//需要把当前登录的用户名传递给游戏界面
new GameJFrame();
} else {
System.out.println("用户名或密码错误");
showJDialog("用户名或密码错误");
}
} else if (e.getSource() == register) {
System.out.println("点击了注册按钮");
//关闭当前的登录界面
this.setVisible(false);
//打开注册界面
new RegisterJFrame(allUsers);
} else if (e.getSource() == rightCode) {
System.out.println("更换验证码");
//获取一个新的验证码
String code = CodeUtil.getCode();
rightCode.setText(code);
}
}
//展示弹框
public void showJDialog(String content) {
//创建一个弹框对象
JDialog jDialog = new JDialog();
//给弹框设置大小
jDialog.setSize(200, 150);
//让弹框置顶
jDialog.setAlwaysOnTop(true);
//让弹框居中
jDialog.setLocationRelativeTo(null);
//弹框不关闭永远无法操作下面的界面
jDialog.setModal(true);
//创建Jlabel对象管理文字并添加到弹框当中
JLabel warning = new JLabel(content);
warning.setBounds(0, 0, 200, 150);
jDialog.getContentPane().add(warning);
//让弹框展示出来
jDialog.setVisible(true);
}
//按下不松
@Override
public void mousePressed(MouseEvent e) {
if (e.getSource() == login) {
login.setIcon(new ImageIcon("puzzlegame\\image\\login\\登录按下.png"));
} else if (e.getSource() == register) {
register.setIcon(new ImageIcon("puzzlegame\\image\\login\\注册按下.png"));
}
}
//松开按钮
@Override
public void mouseReleased(MouseEvent e) {
if (e.getSource() == login) {
login.setIcon(new ImageIcon("puzzlegame\\image\\login\\登录按钮.png"));
} else if (e.getSource() == register) {
register.setIcon(new ImageIcon("puzzlegame\\image\\login\\注册按钮.png"));
}
}
//鼠标划入
@Override
public void mouseEntered(MouseEvent e) {
}
//鼠标划出
@Override
public void mouseExited(MouseEvent e) {
}
//判断用户在集合中是否存在
public boolean contains(User userInput){
for (int i = 0; i < allUsers.size(); i++) {
User rightUser = allUsers.get(i);
if(userInput.getUsername().equals(rightUser.getUsername()) && userInput.getPassword().equals(rightUser.getPassword())){
//有相同的代表存在，返回true，后面的不需要再比了
return true;
}
}
//循环结束之后还没有找到就表示不存在
return false;
}
//在这个界面中添加内容
public void initView() {
//1. 添加用户名文字
JLabel usernameText = new JLabel(new ImageIcon("puzzlegame\\image\\login\\用户名.png"));
usernameText.setBounds(116, 135, 47, 17);
this.getContentPane().add(usernameText);
//2.添加用户名输入框
username.setBounds(195, 134, 200, 30);
this.getContentPane().add(username);
//3.添加密码文字
JLabel passwordText = new JLabel(new ImageIcon("puzzlegame\\image\\login\\密码.png"));
passwordText.setBounds(130, 195, 32, 16);
this.getContentPane().add(passwordText);
//4.密码输入框
password.setBounds(195, 195, 200, 30);
this.getContentPane().add(password);
//验证码提示
JLabel codeText = new JLabel(new ImageIcon("puzzlegame\\image\\login\\验证码.png"));
codeText.setBounds(133, 256, 50, 30);
this.getContentPane().add(codeText);
//验证码的输入框
code.setBounds(195, 256, 100, 30);
code.addMouseListener(this);
this.getContentPane().add(code);
String codeStr = CodeUtil.getCode();
//设置内容
rightCode.setText(codeStr);
//绑定鼠标事件
rightCode.addMouseListener(this);
//位置和宽高
rightCode.setBounds(300, 256, 50, 30);
//添加到界面
this.getContentPane().add(rightCode);
//5.添加登录按钮
login.setBounds(123, 310, 128, 47);
login.setIcon(new ImageIcon("puzzlegame\\image\\login\\登录按钮.png"));
//去除按钮的边框
login.setBorderPainted(false);
//去除按钮的背景
login.setContentAreaFilled(false);
//给登录按钮绑定鼠标事件
login.addMouseListener(this);
this.getContentPane().add(login);
//6.添加注册按钮
register.setBounds(256, 310, 128, 47);
register.setIcon(new ImageIcon("puzzlegame\\image\\login\\注册按钮.png"));
//去除按钮的边框
register.setBorderPainted(false);
//去除按钮的背景
register.setContentAreaFilled(false);
//给注册按钮绑定鼠标事件
register.addMouseListener(this);
this.getContentPane().add(register);
//7.添加背景图片
JLabel background = new JLabel(new ImageIcon("puzzlegame\\image\\login\\background.png"));
background.setBounds(0, 0, 470, 390);
this.getContentPane().add(background);
}
//初始化界面
public void initJFrame() {
this.setSize(488, 430);//设置宽高
this.setTitle("拼图游戏 V1.0登录");//设置标题
this.setDefaultCloseOperation(3);//设置关闭模式
this.setLocationRelativeTo(null);//居中
this.setAlwaysOnTop(true);//置顶
this.setLayout(null);//取消内部默认布局
}
}
import cn.hutool.core.io.FileUtil;
import com.itheima.domain.User;
import javax.swing.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
public class RegisterJFrame extends JFrame implements MouseListener {
ArrayList allUsers;
//提升三个输入框的变量的作用范围，让这三个变量可以在本类中所有方法里面可以使用。
JTextField username = new JTextField();
JTextField password = new JTextField();
JTextField rePassword = new JTextField();
//提升两个按钮变量的作用范围，让这两个变量可以在本类中所有方法里面可以使用。
JButton submit = new JButton();
JButton reset = new JButton();
public RegisterJFrame(ArrayList allUsers) {
this.allUsers = allUsers;
initFrame();
initView();
setVisible(true);
}
@Override
public void mouseClicked(MouseEvent e) {
if(e.getSource() == submit){
//点击了注册按钮
//1.用户名，密码不能为空
if(username.getText().length() == 0 || password.getText().length() == 0 || rePassword.getText().length() == 0){
showDialog("用户名和密码不能为空");
return;
}
//2.判断两次密码输入是否一致
if(!password.getText().equals(rePassword.getText())){
showDialog("两次密码输入不一致");
return;
}
//3.判断用户名和密码的格式是否正确
if(!username.getText().matches("[a-zA-Z0-9]{4,16}")){
showDialog("用户名不符合规则");
return;
}
if(!password.getText().matches("\\S*(?=\\S{6,})(?=\\S*\\d)(?=\\S*[a-z])\\S*")){
showDialog("密码不符合规则，至少包含1个小写字母，1个数字，长度至少6位");
return;
}
//4.判断用户名是否已经重复
if(containsUsername(username.getText())){
showDialog("用户名已经存在，请重新输入");
return;
}
//5.添加用户
allUsers.add(new User(username.getText(),password.getText()));
//6.写入文件
FileUtil.writeLines(allUsers,"C:\\Users\\alienware\\IdeaProjects\\basic-code\\puzzlegame\\userinfo.txt","UTF-8");
//7.提示注册成功
showDialog("注册成功");
//关闭注册界面，打开登录界面
this.setVisible(false);
new LoginJFrame();
}else if(e.getSource() == reset){
//点击了重置按钮
//清空三个输入框
username.setText("");
password.setText("");
rePassword.setText("");
}
}
/*
* 作用：
* 判断username在集合中是否存在
* 参数：
* 用户名
* 返回值：
* true：存在
* false：不存在
*
* */
public boolean containsUsername(String username){
for (User u : allUsers) {
if(u.getUsername().equals(username)){
return true;
}
}
return false;
}
@Override
public void mousePressed(MouseEvent e) {
if (e.getSource() == submit) {
submit.setIcon(new ImageIcon("puzzlegame\\image\\register\\注册按下.png"));
} else if (e.getSource() == reset) {
reset.setIcon(new ImageIcon("puzzlegame\\image\\register\\重置按下.png"));
}
}
@Override
public void mouseReleased(MouseEvent e) {
if (e.getSource() == submit) {
submit.setIcon(new ImageIcon("puzzlegame\\image\\register\\注册按钮.png"));
} else if (e.getSource() == reset) {
reset.setIcon(new ImageIcon("puzzlegame\\image\\register\\重置按钮.png"));
}
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
private void initView() {
//添加注册用户名的文本
JLabel usernameText = new JLabel(new ImageIcon("puzzlegame\\image\\register\\注册用户名.png"));
usernameText.setBounds(85, 135, 80, 20);
//添加注册用户名的输入框
username.setBounds(195, 134, 200, 30);
//添加注册密码的文本
JLabel passwordText = new JLabel(new ImageIcon("puzzlegame\\image\\register\\注册密码.png"));
passwordText.setBounds(97, 193, 70, 20);
//添加密码输入框
password.setBounds(195, 195, 200, 30);
//添加再次输入密码的文本
JLabel rePasswordText = new JLabel(new ImageIcon("puzzlegame\\image\\register\\再次输入密码.png"));
rePasswordText.setBounds(64, 255, 95, 20);
//添加再次输入密码的输入框
rePassword.setBounds(195, 255, 200, 30);
//注册的按钮
submit.setIcon(new ImageIcon("puzzlegame\\image\\register\\注册按钮.png"));
submit.setBounds(123, 310, 128, 47);
submit.setBorderPainted(false);
submit.setContentAreaFilled(false);
submit.addMouseListener(this);
//重置的按钮
reset.setIcon(new ImageIcon("puzzlegame\\image\\register\\重置按钮.png"));
reset.setBounds(256, 310, 128, 47);
reset.setBorderPainted(false);
reset.setContentAreaFilled(false);
reset.addMouseListener(this);
//背景图片
JLabel background = new JLabel(new ImageIcon("puzzlegame\\image\\register\\background.png"));
background.setBounds(0, 0, 470, 390);
this.getContentPane().add(usernameText);
this.getContentPane().add(passwordText);
this.getContentPane().add(rePasswordText);
this.getContentPane().add(username);
this.getContentPane().add(password);
this.getContentPane().add(rePassword);
this.getContentPane().add(submit);
this.getContentPane().add(reset);
this.getContentPane().add(background);
}
private void initFrame() {
//对自己的界面做一些设置。
//设置宽高
setSize(488, 430);
//设置标题
setTitle("拼图游戏 V1.0注册");
//取消内部默认布局
setLayout(null);
//设置关闭模式
setDefaultCloseOperation(3);
//设置居中
setLocationRelativeTo(null);
//设置置顶
setAlwaysOnTop(true);
}
//只创建一个弹框对象
JDialog jDialog = new JDialog();
//因为展示弹框的代码，会被运行多次
//所以，我们把展示弹框的代码，抽取到一个方法中。以后用到的时候，就不需要写了
//直接调用就可以了。
public void showDialog(String content){
if(!jDialog.isVisible()){
//把弹框中原来的文字给清空掉。
jDialog.getContentPane().removeAll();
JLabel jLabel = new JLabel(content);
jLabel.setBounds(0,0,200,150);
jDialog.add(jLabel);
//给弹框设置大小
jDialog.setSize(200, 150);
//要把弹框在设置为顶层 -- 置顶效果
jDialog.setAlwaysOnTop(true);
//要让jDialog居中
jDialog.setLocationRelativeTo(null);
//让弹框
jDialog.setModal(true);
//让jDialog显示出来
jDialog.setVisible(true);
}
}
}
import java.util.ArrayList;
import java.util.Random;
public class CodeUtil {
public static String getCode(){
//1.创建一个集合
ArrayList list = new ArrayList<>();//52 索引的范围：0 ~ 51
//2.添加字母 a - z A - Z
for (int i = 0; i < 26; i++) {
list.add((char)('a' + i));//a - z
list.add((char)('A' + i));//A - Z
}
//3.打印集合
//System.out.println(list);
//4.生成4个随机字母
String result = "";
Random r = new Random();
for (int i = 0; i < 4; i++) {
//获取随机索引
int randomIndex = r.nextInt(list.size());
char c = list.get(randomIndex);
result = result + c;
}
//System.out.println(result);//长度为4的随机字符串
//5.在后面拼接数字 0~9
int number = r.nextInt(10);
//6.把随机数字拼接到result的后面
result = result + number;
//System.out.println(result);//ABCD5
//7.把字符串变成字符数组
char[] chars = result.toCharArray();//[A,B,C,D,5]
//8.在字符数组中生成一个随机索引
int index = r.nextInt(chars.length);
//9.拿着4索引上的数字，跟随机索引上的数字进行交换
char temp = chars[4];
chars[4] = chars[index];
chars[index] = temp;
//10.把字符数组再变回字符串
String code = new String(chars);
//System.out.println(code);
return code;
}
}
单词
