字符集详解

核心1：GBK中，一个英文字母一个字节，二进制第一位是0
核心2：GBK中，一个中文汉字两个字节，二进制第一位是1

解码与编码方法

Java中编码的方法
使用默认方式进行编码  public byte[] getBytes()
使用指定方式进行编码 public byte[] getBytes(String charsetName)Java中解码的方法
使用默认方式进行解码 String(byte[] bytes)
使用指定方式进行解码 String(byte[] bytes, String charsetName)

字符流

方法：close（）

FileWriter

1创建字符输出流对象
细节1：参数是字符串表示的路径或者File对象都是可以的
细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的
细节3：如果文件已经存在，则会清空文件，如果不想清空可以打开续写开关
2写数据
细节：如果write方法的参数是整数，但是实际上写到本地文件中的是整数在字符集上对应的字符
3释放资源
细节：每次使用完流之后都要释放资源

拷贝文件夹

参数一：数据源
参数二：目的地

private static void copydir(File src, File dest) throws IOException {
dest.mkdirs();
//递归
//1.进入数据源
File[] files = src.listFiles();
//2.遍历数组
for (File file : files) {
if(file.isFile()){
//3.判断文件，拷贝
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest,file.getName()));
byte[] bytes = new byte[1024];
int len;
while((len = fis.read(bytes))!=-1){
fos.write(bytes,0,len);
}
fos.close();
fis.close();
}else {
//4.判断文件夹，递归
copydir(file, new File(dest,file.getName()));
}
}
}

字节缓冲流拷贝文件（一次读写一个字节）

//1.创建缓冲流的对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(  "myiolla.txt")):
BufferedoutputStream bos = new BufferedoutputStream(new FileoutputStream(  "myio\\copy.txt"));
//2.循环读取并写到目的地
int b;
while ((b = bis.read()) != -1) {
bos.write(b);
}
//3.释放资源
bos.close();
bis.close();

字节缓冲流拷贝文件（一次读写一个字节数组）

//1.创建缓冲流的对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(  "myiolla.txt")):
BufferedoutputStream bos = new BufferedoutputStream(new FileoutputStream(  "myio\\copy.txt"));
//2.拷贝（一次读写多个字节）
byte[] bytes = new byte[1024];
int len;|
while((len = bis.read(bytes)) != -1){
bos.write(bytes, off: 9,len);
}
//3.释放资源
bos.close();
bis.close();

字符缓冲流

注：readLine方法在读取的时候，一次读一整行，遇到回车换行结束
但是他不会把回车换行读到内存当中

开启续写：

(new Filewriter( "b.txt", true)

控制软件运行次数

//1.把文件中的数字读取到内存中
//原则：
//IO：随用随创建
什么时候不用什么时候关闭
//
BufferedReader br = new BufferedReader(new FileReader(  "myio\\count.txt"));
String line = br.readLine();
br.close();
System.out.println(line);//null
int count = Integer.parseInt(line);
//表示当前软件又运行了一次
count++;//1
//2.判断
点赞成功
if(count <= 3){
System.out.println("欢迎使用本软件，第"+count+"次使用免费～")；
}else{
System.out.println("本软件只能免费使用3次，欢迎您注册会员后继续使用～")；
3
Bufferedwriter bw = new BufferedWriter(new FileWriter(  "myio\\count.txt"));
//3.把当前自增之后的count写出到文件当中
bw.write( count + ""); //97 + ""
bw.close();

转换流：

//1.JDK11以前的方案
/* InputStreamReader isr = new InputStreamReader(new FileInputStream("myio\\b.txt"),"GBK");
OutputStreamwriter osw = new OutputStreamwriter(new FileOutputStream("myio\\d.txt"),"UTF-8");
int b;
while((b = isr.read()) != -1)f
osw.write(b);
}
osw.close();
isr.close();*///2.替代方案
FileReader fr = new FileReader(fileName: "myio\\b.txt", Charset.forName("GBK"));
FileWriter fw = new FileWriter(fileName: "myio\\e.txt",Charset.forName("UTF-8"));
int b;
while ((b = fr.read()) != -1){
fw.write(b);
}
fw.close();

序列化流

序列化流的小细节：使用对象输出流将对象保存到文件时会出现NotSerializableException异常

解决方案：需要让Javabean类实现Serializable接口

反序列化流/对象操作输入流

打印流

字节打印流

解压缩流

/解压的本质：把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地当中
1X1
//创建一个解压缩流用来读取压缩包中的数据
ZipInputStream zip = new ZipInputStream(new FileInputStream(src));
I//要先获取到压缩包里面的每一个zipentry对象
/表示当前在压缩包中获取到的文件或者文件夹
ZipEntry entry;
while((entry = zip.getNextEntry()) != null){
System.out.println(entry);
if(entry.isDirectory()){
//文件夹：需要在目的地dest处创建一个同样的文件夹
File file = new File(dest,entry.toString());
file.mkdirs();
}else{
//文件：需要读取到压缩包中的文件，并把他存放到目的地dest文件夹中(按照层级目录进行存放
FileOutputStream fos = new FileOutputStream(new File(dest,entry.toString()));
int b;
while((b = zip.read()) != -1){
/写到目的地
fos.write(b);
}
fos.close();
/表示在压缩包中的一个文件处理完毕了。
zip.closeEntry();
}
}
zip.close();

网络爬虫

/*
*作用：
从网络中爬取数据，把数据拼接成字符串返回
*
*形参：
网址
*
*返回值：
爬取到的所有数据
*
* */
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.定义变量记录网址
String familyNameNet = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4cOddb3ee693fdb1137ee1bod&from=kge";
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);
System.out.println(girlNameTempList);

l利用糊涂包生成假数据

//1.定义变量记录网址
String familyNameNet = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4cOddb3ee693fdb1137ee1bod&from=kge";
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);
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]);
}
}

带权重的随机数

//1.把文件中所有的学生信息读取到内存中
ArrayList<Student> list = new ArrayList<>();
BufferedReader br = new BufferedReader(new FileReader()；
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.计算每一个人的实际占比
double[] arr = new doubleylist.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];
}
System.out.println(Arrays.tostring(arr));
//5.随机抽取
//获取一个e.0~1.0之间的随机数
double number = Math.random();
//判断number在arr中的位置
/二分查找法
//方法回返回：-插入点-1
int index2 = Arrays.binarySearch(arr, number);
System.out.println(Arrays.tostring(arr));
System.out.println(number);
System.out.println(index2);

登录

//1.读取正确的用户名和密码
BufferedReader br = new BufferedReader(new FileReader())
String line = br.readLine();//username=zhangsan&password=123
br.close();
String[] userInfo = line.split(  "&");
String[] arr1 = userInfo[e].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) && rightPasswohsd.equals(password)){
System.out.println("登陆成功");
}else{
System.out.println("登陆失败");
}

存档读档

//直接把游戏的数据写到本地文件中
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileoutputStream( "puzzlegame\\save\\save" + index + ".data".
GameInfo gi = new GameInfo(data, x, y, path, step);
IoUtil.write0bj(oos, isCloseOut: true, gi);
} catch (IOException ioException) (
ioException.printStackTrace();
}
//修改一下存档item上的展示信息
//存档e（xx步）
item.setText("存档"+index+"（"+step+"步）");

//获取当前是哪个读档被点击了，获取其中的序号
JMenuItem item = (JMenuItem) obj;
String str = item.getText();
int index = str.charAt(2) - '0';
GameInfo gi = null;
try {
/可以到本地文件中读取数据
ObjectInputstream ois = newObjectInputstream(new FileInputStream(  "puzzlegame\\save\\save" + index + ".data
gi = (GameInfo)ois.readobject();
ois.close();
} catch (IOException ioException) {
ioException.printStackTrace();
} catch (ClassNotFoundException classNotFoundException) {
classNotFoundException.printStackTrace();
3
data = gi.getData();
path = gi.getPath();
step = gi.getStep();
× = gi.getx();
y = gi.getY();
∥重新刷新界面加载游戏
initImage();

数据同步

//1.创建File对象表示所有存档所在的文件夹
File file = new File( "puzzlegame\\save");
//2.进入文件夹获取到里面所有的存档文件
File[] files = file.listFiles();
//3.遍历数组，得到每一个存档
for (File f : files) {
//f：依次表示每一个存档文件
/获取每一个存档文件中的步数
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));
GameInfo gi = (GameInfo)ois.readObject();
ois.close();
//获取到了步数
int step = gi.getStep();
}∥把存档的步数同步到菜单当中
//saveO ---> 0
//save1 ---> 1
//.….
//获取存档的文件名 savee.data
String name = f.getName();
//获取当存档的序号（索引）
int index = name.charAt(4) - '0';
∥修改菜单上所表示的文字信息
saveJMenu.getItem(index).setText("存档"+index +"("+ step+")步");
loadJMenu.getItem(index).setText("存档"+index+"("+step+")步");

properties

//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( name: "myiotest\\a.properties");
prop.store(fos, comments: "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();
3
bw.close();*/