目录
- 0 目录
- 一、听黑马阿玮的视频记录的笔记
- 1. 制造假数据
- 1.1 如何制造假数据
- 1.2 练习1-生成方式1：爬取姓氏、男生名字、女生名字
- 1.3 练习2-生成方式1：在练习1的基础上，将数据写入本地文件
- 1.4 练习3-生成方式2：利用糊涂包生成假数据
- 2.随机点名器
- 2.1 练习：前4个练习以及对应代码
- 2.1.1 需求与代码
- 2.1.2 需求与代码
- 2.1.3 需求与代码
- 2.1.4 需求与代码
- 2.2 练习：随机点名器5
- 3.登录注册
- 3.1 练习：登录注册1
- 3.2 练习：登录注册2（需独立完成）
- 3.3 练习：登录注册3
- 3.4 练习：登录注册4（需独立完成）
- 4.游戏存档和读档
- 3.1 练习：游戏存档
- 3.2 练习：游戏读档
- 3.3 练习：数据同步
- 5.游戏配置
- 5.1 properties的基本使用
- 5.1.1 什么是配置文件
- 5.1.2 配置文件的好处
- 5.1.3 常见的配置文件
- 5.1.4 properties配置文件
- 5.1.5 练习：Properties作为Map集合的操作
- 5.1.6 练习：Properties跟IO流结合的操作
- 5.1.7 练习：读取本地Properties文件里面的数据
- 5.2 练习：游戏配置
- 6.每日一记
- 6.1 练习1：课后作业
- 6.1 练习2：导出和导入的功能 - 基于练习1的课后作业
- 页末
说明：该笔记是根据黑马程序员在B站上分享的视频 黑马程序员Java零基础视频教程_下部的资料而整理的笔记， 完全来源于黑马程序员，若有侵权，请联系本人删除，个人加了空格，也根据视频 加了一些内容、详细的运行结果图与源码图。笔记难免可能出现错误或笔误， 若读者发现笔记有错误，欢迎在评论里批评指正。关于 前十三章笔记，个人在知乎上有所记录，很详细，但时间来不急了，不能慢慢记录了，对应链接： 知乎上的Java笔记。 笔记于2024.12.7在开始记录，12.8记录完毕。
（废话一句。目前经济环境很差，转Java的相当多，不一定是最佳选择，会挤得头破血流。建议大家也可以考虑分流，C++（学了语言后，往语音信号处理、嵌入式等地方再搞一搞）、嵌入式、FPGA、硬件（硬件，很多企业会用到，有机会、有能力、有条件的，建议试试）、考公选调与国考、电网。）
另外，本章应该会有点爬虫知识，所以特此声明：请合法合理使用爬虫，不爬取任何涉密以及涉及隐私的内容，合理控制请求次数，爬取的内容未经授权请不要用于商用，保护自己，免受牢狱之灾。
0 目录
一、听黑马阿玮的视频记录的笔记
1. 制造假数据
注：对应视频为：1O流-45-综合练习01-网络爬虫（爬取姓氏）、IO流-46-综合练习02-网络爬虫（爬取名字）、IO流-47-综合练习03-网络爬虫（数据处理）、IO流-48-综合练习04-网络爬虫（数据处理并写出）、IO流-49-综合练习05-利用糊涂包生成假数据。
1.1 如何制造假数据
1.2 练习1-生成方式1：爬取姓氏、男生名字、女生名字
对应视频为：1O流-45-综合练习01-网络爬虫（爬取姓氏）、IO流-46-综合练习02-网络爬虫（爬取名字）、IO流-47-综合练习03-网络爬虫（数据处理）、IO流-48-综合练习04-网络爬虫（数据处理并写出），不理解的地方请在视频中直接听，比纯看博客好理解得多。
Test1
package com.itheima.myiotest1;
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<String> familyNameTempList = getData(familyNameStr,"(.{4})(，|。)",1);
ArrayList<String> boyNameTempList = getData(boyNameStr,"([\\u4E00-\\u9FA5]{2})(、|。)",1);
ArrayList<String> girlNameTempList = getData(girlNameStr,"(.. ){4}..",0);
//4.处理数据
//familyNameTempList（姓氏）
//处理方案：把每一个姓氏拆开并添加到一个新的集合当中
ArrayList<String> 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<String> boyNameList = new ArrayList<>();
for (String str : boyNameTempList) {
if(!boyNameList.contains(str)){
boyNameList.add(str);
}
}
//girlNameTempList（女生的名字）
//处理方案：把里面的每一个元素用空格进行切割，得到每一个女生的名字
ArrayList<String> 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<String> 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<String> getInfos(ArrayList<String> familyNameList,ArrayList<String> boyNameList,ArrayList<String> girlNameList, int boyCount,int girlCount){
//1.生成男生不重复的名字
HashSet<String> 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<String> 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<String> 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<String> getData(String str, String regex,int index) {
//1.创建集合存放数据
ArrayList<String> 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();
}
}
运行结果 - 爬取姓氏网址后获取的网页源码
运行结果 - 爬取男生名字网址后获取的网页源码
运行结果 - 根据姓氏的网页源码获取姓氏，使用正则表达式
然后，为了得到男生名字，我们需要在网页中观察数据。
运行结果 - 根据男生名字的网页源码获取男生名字，使用正则表达式
运行结果 - 根据女生名字的网页源码获取女生名字，使用正则表达式
运行结果 - 进一步处理获取到的姓氏数据，将姓氏提取出来
运行结果 - 进一步处理获取到的男生名字数据，将男生名字提取出来
运行结果 - 进一步处理获取到的女生名字数据，将女生名字提取出来
运行结果 - 随机生成不重复的男生的姓名
运行结果 - 随机生成不重复的女生的姓名
运行结果 - 随机生成不重复的且带年龄的姓名
- 第1张图的名字没被打乱
- 第2张图的名字被打乱了
1.3 练习2-生成方式1：在练习1的基础上，将数据写入本地文件
对应视频为：IO流-48-综合练习04-网络爬虫（数据处理并写出），不理解的地方请在视频中直接听，比纯看博客好理解得多。
剩余代码见练习1的Test1。
运行结果 - 将数据写入本地文件
1.4 练习3-生成方式2：利用糊涂包生成假数据
对应视频为：IO流-49-综合练习05-利用糊涂包生成假数据，不理解的地方请在视频中直接听，比纯看博客好理解得多。
在糊涂包的文档中查看爬虫的代码示例。
Test2
package com.itheima.myiotest1;
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<String> familyNameTempList = ReUtil.findAll("(.{4})(，|。)", familyNameStr, 1);
List<String> boyNameTempList = ReUtil.findAll("([\\u4E00-\\u9FA5]{2})(、|。)", boyNameStr, 1);
List<String> girlNameTempList = ReUtil.findAll("(.. ){4}..", girlNameStr, 0);
System.out.println(familyNameTempList);
System.out.println(boyNameTempList);
System.out.println(girlNameTempList);
//4.处理数据
//familyNameTempList（姓氏）
//处理方案：把每一个姓氏拆开并添加到一个新的集合当中
ArrayList<String> 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<String> boyNameList = new ArrayList<>();
for (String str : boyNameTempList) {
if(!boyNameList.contains(str)){
boyNameList.add(str);
}
}
//girlNameTempList（女生的名字）
//处理方案：把里面的每一个元素用空格进行切割，得到每一个女生的名字
ArrayList<String> 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<String> list = getInfos(familyNameList, boyNameList, girlNameList, 70, 50);
Collections.shuffle(list);
//6.写出数据
//细节：
//糊涂包的相对路径，不是相对于当前项目而言的，而是相对class文件而言的
FileUtil.writeLines(list,"D:\\names.txt","UTF-8");
}
/*
* 作用：
* 获取男生和女生的信息：张三-男-23
*
* 形参：
* 参数一：装着姓氏的集合
* 参数二：装着男生名字的集合
* 参数三：装着女生名字的集合
* 参数四：男生的个数
* 参数五：女生的个数
* */
public static ArrayList<String> getInfos(ArrayList<String> familyNameList,ArrayList<String> boyNameList,ArrayList<String> girlNameList, int boyCount,int girlCount){
//1.生成男生不重复的名字
HashSet<String> 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<String> 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<String> 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;
}
}
写代码的过程时的小细节
运行结果 - 使用hutool初步获取网页中的姓氏、男生名字、女生名字
运行结果 - 处理数据、写出数据到本地文件（剩下代码除写入文件外，其余与方式1同）
2.随机点名器
注：对应视频为：IO流-50-综合练习06-随机点名器的四个需求、IO流-51-综合练习07-带权重的随机算法。
2.1 练习：前4个练习以及对应代码
对应视频为：IO流-50-综合练习06-随机点名器的四个需求。
2.1.1 需求与代码
Test
package com.itheima.myiotest2;
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<String> 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]);
}
}
2.1.2 需求与代码
Test
package com.itheima.myiotest3;
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<String> boyNameList = new ArrayList<>();
ArrayList<String> 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<Integer> 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);
}
}
2.1.3 需求与代码
Test
package com.itheima.myiotest4;
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<String> 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();
}
}
2.1.4 需求与代码
Test
package com.itheima.myiotest5;
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<String> 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<String> 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<String> readFile(String pathFile) throws IOException {
ArrayList<String> list = new ArrayList<>();
BufferedReader br = new BufferedReader(new FileReader(pathFile));
String line;
while ((line = br.readLine()) != null) {
list.add(line);
}
br.close();
return list;
}
}
2.2 练习：随机点名器5
对应视频为：IO流-51-综合练习07-带权重的随机算法，不理解的地方请在视频中直接听，比纯看博客好理解得多。
- 权重占比的思考
Student
package com.itheima.myiotest6;
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;
}
}
Test
package com.itheima.myiotest6;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
public class Test {
public static void main(String[] args) throws IOException {
//1.把文件中所有的学生信息读取到内存中
ArrayList<Student> 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();
}
}
运行结果 - 读取学生信息
运行结果 - 数据处理，作为学生对象添加到集合中
运行结果 - 计算权重的总和
运行结果 - 计算每一个人的实际占比
运行结果 - 计算每一个人的权重占比范围
运行结果 - 第一次随机抽取索引，使用二分查找法
运行结果 - 第一次随机抽取到的同学
运行结果 - 第一次随机抽取到的同学后，需要修改对应的权重
运行结果 - 多次随机抽取到的同学后，且修改完对应的权重后，再将数据写入文件
3.登录注册
注：对应视频为：IO流-52-综合练习08-登录注册、IO流-53-综合练习09-拼图游戏 (导入项目)、IO流-54-综合练习10-拼图游戏 (登录界面）、IO流-55-综合练习11-拼图游戏 (注册界面)。
3.1 练习：登录注册1
对应视频为：IO流-52-综合练习08-登录注册，不理解的地方请在视频中直接听，比纯看博客好理解得多。
准备好的文件。
Test
package com.itheima.myiotest7;
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("登陆失败");
}
}
}
运行结果 - 读取文件里的数据
运行结果 - 读取正确的用户名和密码
运行结果 - 用户键盘录入用户名和密码，然后比较文件中的用户信息和键盘输入的是否一致
3.2 练习：登录注册2（需独立完成）
Test
package com.itheima.myiotest8;
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();
}
}
3.3 练习：登录注册3
对应视频为：IO流-53-综合练习09-拼图游戏 (导入项目)、IO流-54-综合练习10-拼图游戏 (登录界面）、IO流-55-综合练习11-拼图游戏 (注册界面)，需要的自己看视频。笔记里就不记全了，反正忘得快。
登录。
注册。
3.4 练习：登录注册4（需独立完成）
4.游戏存档和读档
注：对应视频为：IO流-56-综合练习12-拼图游戏 (存档)、IO流-56-综合练习13-拼图游戏 (读档)、IO流-56-综合练习13-拼图游戏 (数据同步)。
3.1 练习：游戏存档
对应视频为：IO流-56-综合练习12-拼图游戏 (存档)，需要的自己看视频。笔记里就不记全了，反正忘得快。
3.2 练习：游戏读档
对应视频为：IO流-56-综合练习13-拼图游戏 (读档)，需要的自己看视频。笔记里就不记全了，反正忘得快。
3.3 练习：数据同步
对应视频为：IO流-56-综合练习13-拼图游戏 (数据同步)，需要的自己看视频。笔记里就不记全了，反正忘得快。
5.游戏配置
注：对应视频为：IO流-57-综合练习15-properties的基本使用、IO流-58-综合练习16-拼图游戏 (配置文件)。
5.1 properties的基本使用
对应视频为：IO流-57-综合练习15-properties的基本使用，需要的自己看视频。
5.1.1 什么是配置文件
5.1.2 配置文件的好处
5.1.3 常见的配置文件
5.1.4 properties配置文件
5.1.5 练习：Properties作为Map集合的操作
Test1
package com.itheima.myiotest9;
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);
}*/
}
}
没有指定泛型。
运行结果 - Properties结合的键是不会重复的，是唯一的
运行结果 - 打印Properties集合
运行结果 - 遍历Properties集合
5.1.6 练习：Properties跟IO流结合的操作
Test2
package com.itheima.myiotest9;
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();*/
}
}
运行结果 - 把集合中的数据以键值对的形式写到本地文件当中，使用之前的方式，非常麻烦
运行结果 - 把集合中的数据以键值对的形式写到本地文件当中，使用Properties的特有方法
5.1.7 练习：读取本地Properties文件里面的数据
Test3
package com.itheima.myiotest9;
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);
}
}
运行结果 - 读取本地Properties文件里面的数据
5.2 练习：游戏配置
对应视频为：IO流-58-综合练习16-拼图游戏 (配置文件)，需要的自己看视频。笔记里就不记全了，反正忘得快。
6.每日一记
注：对应视频为：IO流-59-综合练习17-每日一记 (阶段大作业)，需要的自己看视频。笔记里就不记全了，反正忘得快。
6.1 练习1：课后作业
添加
修改
修删除
6.1 练习2：导出和导入的功能 - 基于练习1的课后作业
好，本次笔记到此结束。
