java笔记07
9.异常综合练习
package a09_综合练习;import java.util.Scanner;public class Test {public static void main(String[] args) {/*需求：键盘录入自己心仪的女朋友姓名和年龄。姓名的长度在 3 - 10之间，年龄的范围为 18 - 40岁，超出这个范围是异常数据不能赋值，需要重新录入，一直录到正确为止。提示：需要考虑用户在键盘录入时的所有情况。比如：录入年龄时超出范围，录入年龄时录入了abc等情况*///1.创建键盘录入的对象Scanner sc = new Scanner(System.in);//2.创建女朋友的对象GirlFriend gf = new GirlFriend();while (true) {try {//3.接收女朋友的姓名System.out.println("请输入你心仪的女朋友的名字");String name = sc.nextLine();gf.setName(name);//4.接收女朋友的年龄System.out.println("请输入你心仪的女朋友的年龄");String ageStr = sc.nextLine();int age = Integer.parseInt(ageStr);gf.setAge(age);//如果所有的数据都是正确的，那么跳出循环break;} catch (NumberFormatException e) {System.out.println("年龄的格式有误，请输入数字");//continue;} catch (RuntimeException e) {System.out.println("姓名的长度或者年龄的范围有误");//continue;}}//5.打印System.out.println(gf);}
}
package a09_综合练习;public class GirlFriend {private String name;private int age;public GirlFriend() {}public GirlFriend(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {int len = name.length();if(len < 3 || len > 10){throw new RuntimeException();}this.name = name;}public int getAge() {return age;}public void setAge(int age) {if(age < 18 || age > 40){throw new RuntimeException();}this.age = age;}
}
10.自定义异常
package a10_自定义异常;public class NameFormatException extends RuntimeException{//自定义异常//1.定义异常类//2.写继承关系//3.空参构造//4.带参构造//意义：就是为了让控制台的报错信息更加的见名之意//技巧：//NameFormat：当前异常的名字，表示姓名格式化问题//Exception：表示当前类是一个异常类//运行时：RuntimeException 核心 就表示由于参数错误而导致的问题//编译时：Exception 核心 提醒程序员检查本地信息public NameFormatException() {}public NameFormatException(String message) {super(message);}
}
public void setName(String name) {int len = name.length();if(len < 3 || len > 10){throw new NameFormatException(name + "格式有误，长度应该为：3~10");}this.name = name;
}
package a10_自定义异常;public class AgeOutOfBoundsException extends RuntimeException{public AgeOutOfBoundsException() {}public AgeOutOfBoundsException(String message) {super(message);}
}
public void setAge(int age) {if(age < 18 || age > 40){throw new AgeOutOfBoundsException(age + "超出了范围");}this.age = age;
}
File
1.File的概述和构造方法
File File 对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径 这个路径可以是存在的，也允许是不存在的方法名称 说明 public File(String pathname) 根据文件路径创建文件对象 public File(String parent, String child) 根据父路径名字符串和子路径名字符串创建文件对象 public File(File parent, String child) 根据父路径对应文件对象和子路径名字符串创建文件对象
package a01_File的概述和构造方法;import java.io.File;public class Test {public static void main(String[] args) {
// C:\Users\alienware\Desktop//1.根据字符串表示的路径，变成File对象String str = "C:\\Users\\alienware\\Desktop\\a.txt";File f1 = new File(str);System.out.println(f1);//C:\Users\alienware\Desktop\a.txt//2.父级路径：C:\Users\alienware\Desktop//子级路径：a.txtString parent = "C:\\Users\\alienware\\Desktop";String child = "a.txt";File f2 = new File(parent,child);System.out.println(f2);//C:\Users\alienware\Desktop\a.txtFile f3 = new File(parent + "\\" + child);System.out.println(f3);//C:\Users\alienware\Desktop\a.txt//3.把一个File表示的路径和String表示路径进行拼接File parent2 = new File("C:\\Users\\alienware\\Desktop");String child2 = "a.txt";File f4 = new File(parent2,child2);System.out.println(f4);//C:\Users\alienware\Desktop\a.txt}
}
总结： 1.File 表示什么？File 对象表示路径，可以是文件、也可以是文件夹。这个路径可以是存在的，也可以是不存在的 2.绝对路径和相对路径是什么意思？绝对路径是带盘符的。相对路径是不带盘符的，默认到当前项目下去找。 3.File 三种构造方法的作用？public File (String pathname)：把字符串表示的路径变成 File 对象public File (String parent, String child)：把父级路径和子级路径进行拼接public File (File parent, String child)：把父级路径和子级路径进行拼接
2.File的成员方法
1.判断
public boolean isDirectory() 判断此路径名表示的File是否为文件夹 public boolean isFile() 判断此路径名表示的File是否为文件 public boolean exists() 判断此路径名表示的File是否存在
package a02_File的成员方法;import java.io.File;public class a01_判断 {public static void main(String[] args) {//1.对一个文件的路径进行判断File f1 = new File("D:\\aaa\\a.txt"); // 文件System.out.println(f1.isDirectory());//falseSystem.out.println(f1.exists());//trueSystem.out.println(f1.isFile());//trueSystem.out.println("----------------------------------");//2.对一个文件夹的路径进行判断File f2 = new File("D:\\aaa\\bbb"); // 文件夹System.out.println(f2.isDirectory());//trueSystem.out.println(f2.exists());//falseSystem.out.println(f2.isFile());//trueSystem.out.println("----------------------------------");//3.对一个不存在的路径进行判断File f3 = new File("D:\\aaa\\c.txt");System.out.println(f3.isDirectory());//falseSystem.out.println(f3.isFile());//falseSystem.out.println(f3.exists());//false}
}
2.获取
public long length() 返回文件的大小（字节数量） public String getAbsolutePath() 返回文件的绝对路径 public String getPath() 返回定义文件时使用的路径 public String getName() 返回文件的名称，带后缀 public long lastModified() 返回文件的最后修改时间（时间毫秒值）
package a02_File的成员方法;import java.io.File;public class a02_获取 {public static void main(String[] args) {//1.length 返回文件的大小（字节数量）//细节1：这个方法只能获取文件的大小，单位是字节//如果单位我们要是M，G，可以不断的除以1024//细节2：这个方法无法获取文件夹的大小//如果我们要获取一个文件夹的大小，需要把这个文件夹里面所有的文件大小都累加在一起。File f1 = new File("D:\\aaa\\a.txt");long len = f1.length();System.out.println(len);//12File f2 = new File("D:\\aaa\\bbb");long len2 = f2.length();System.out.println(len2);//0System.out.println("========================");//2.getAbsolutePath 返回文件的绝对路径File f3 = new File("D:\\aaa\\a.txt");String path1 = f3.getAbsolutePath();System.out.println(path1);File f4 = new File("File\\a.txt");String path2 = f4.getAbsolutePath();System.out.println(path2);System.out.println("========================");//3.getPath 返回定义文件时使用的路径File f5 = new File("D:\\aaa\\a.txt");String path3 = f5.getPath();System.out.println(path3);//D:\aaa\a.txtFile f6 = new File("myFile\\a.txt");String path4 = f6.getPath();System.out.println(path4);//myFile\a.txtSystem.out.println("==========================");//4.getName 获取名字//细节1://a.txt:// a 文件名// txt 后缀名、扩展名//细节2：//文件夹：返回的就是文件夹的名字File f7 = new File("D:\\aaa\\a.txt");String name1 = f7.getName();System.out.println(name1);File f8 = new File("D:\\aaa\\bbb");String name2 = f8.getName();System.out.println(name2);//bbbSystem.out.println("==========================");//5.lastModified 返回文件的最后修改时间（时间毫秒值）File f9 = new File("D:\\aaa\\a.txt");long time = f9.lastModified();System.out.println(time);//1667389952425}
}
3.创建
public boolean createNewFile() 创建一个新的空的文件 public boolean mkdir() 创建单级文件夹 public boolean mkdirs() 创建多级文件夹
package a02_File的成员方法;import java.io.File;public class a03_创建 {public static void main(String[] args) {//1.createNewFile 创建一个新的空的文件//细节1：如果当前路径表示的文件是不存在的，则创建成功，方法返回true// 如果当前路径表示的文件是存在的，则创建失败，方法返回false//细节2：如果父级路径是不存在的，那么方法会有异常IOException//细节3：createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件/*File f1 = new File("D:\\aaa\\ddd");boolean b = f1.createNewFile();System.out.println(b);//true*///2.mkdir make Directory，文件夹（目录）//细节1：windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false//细节2：mkdir方法只能创建单级文件夹，无法创建多级文件夹。/* File f2 = new File("D:\\aaa\\aaa\\bbb\\ccc");boolean b = f2.mkdir();System.out.println(b);*///3.mkdirs 创建多级文件夹//细节：既可以创建单级的，又可以创建多级的文件夹File f3 = new File("D:\\aaa\\ggg");boolean b = f3.mkdirs();System.out.println(b);//true}
}
4.删除
public boolean delete() 删除文件、空文件夹 细节：如果删除的是文件，则直接删除，不走回收站。如果删除的是空文件夹，则直接删除，不走回收站如果删除的是有内容的文件夹，则删除失败
package a02_File的成员方法;import java.io.File;public class a04_删除 {public static void main(String[] args) {//1.创建File对象File f1 = new File("D:\\aaa\\eee");//2.删除boolean b = f1.delete();System.out.println(b);}
}
5.获取并遍历
方法名称 说明 public File[] listFiles() 获取当前该路径下所有内容当调用者 File 表示的路径不存在时，返回 null 当调用者 File 表示的路径是文件时，返回 null 当调用者 File 表示的路径是一个空文件夹时，返回一个长度为 0 的数组 当调用者 File 表示的路径是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在 File 数组中返回 当调用者 File 表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在 File 数组中返回，包含隐藏文件 当调用者 File 表示的路径是需要权限才能访问的文件夹时，返回 null
package a02_File的成员方法;import java.io.File;public class a05_获取并遍历 {public static void main(String[] args) {//1.创建File对象File f = new File("D:\\aaa");//2.listFiles方法//作用：获取aaa文件夹里面的所有内容，把所有的内容放到数组中返回File[] files = f.listFiles();for (File file : files) {//file依次表示aaa文件夹里面的每一个文件或者文件夹System.out.println(file);}}
}
6.所有获取并遍历的方法
方法名称 说明 public static File[] listRoots() 列出可用的文件系统根 public String[] list() 获取当前该路径下所有内容 public String[] list(FilenameFilter filter) 利用文件名过滤器获取当前该路径下所有内容
//1.listRoots 获取系统中所有的盘符
File[] arr = File.listRoots();
System.out.println(Arrays.toString(arr));//2.list() 获取当前该路径下所有内容(仅仅能获取名字)
File f1 = new File("D:\\aaa");
String[] arr2 = f1.list();
for (String s : arr2) {System.out.println(s);
}//3.list(FilenameFilter filter) 利用文件名过滤器获取当前该路径下所有内容
//需求：我现在要获取D:\\aaa文件夹里面所有的txt文件
File f2 = new File("D:\\aaa");
//accept方法的形参，依次表示aaa文件夹里面每一个文件或者文件夹的路径
//参数一：父级路径
//参数二：子级路径
//返回值：如果返回值为true，就表示当前路径保留
// 如果返回值为false，就表示当前路径舍弃不要
String[] arr3 = f2.list(new FilenameFilter() {@Overridepublic boolean accept(File dir, String name) {File src = new File(dir,name);return src.isFile() && name.endsWith(".txt");}
});
System.out.println(Arrays.toString(arr3));
public File[] listFiles() 获取当前该路径下所有内容(重点)
//1.创建File对象
File f = new File("D:\\aaa");
//2.需求：打印里面所有的txt文件
File[] arr = f.listFiles();
for (File file : arr) {//file依次表示aaa文件夹里面每一个文件或者文件夹的路径if(file.isFile() && file.getName().endsWith(".txt")){System.out.println(file);}
}
public File[] listFiles(FileFilter filter) 利用文件名过滤器获取当前该路径下所有内容 public File[] listFiles(FilenameFilter filter) 利用文件名过滤器获取当前该路径下所有内容
//创建File对象
File f = new File("D:\\aaa");
//调用listFiles(FileFilter filter)
File[] arr1 = f.listFiles(new FileFilter() {@Overridepublic boolean accept(File pathname) {return pathname.isFile() && pathname.getName().endsWith(".txt");}
});//调用listFiles(FilenameFilter filter)
File[] arr2 = f.listFiles(new FilenameFilter() {@Overridepublic boolean accept(File dir, String name) {File src = new File(dir, name);return src.isFile() && name.endsWith(".txt");}
});
System.out.println(Arrays.toString(arr2));
3.File综合练习
1.创建文件
package a03_File综合练习;import java.io.File;
import java.io.IOException;public class a01_创建文件 {public static void main(String[] args) throws IOException {//需求：在当前模块下的aaa文件夹中创建一个a.txt文件//1.创建a.txt的父级路径File file = new File("a22_File\\aaa");//2.创建父级路径//如果aaa是存在的，那么此时创建失败的。//如果aaa是不存在的，那么此时创建成功的。file.mkdirs();//3.拼接父级路径和子级路径File src = new File(file, "a.txt");boolean b = src.createNewFile();if(b){System.out.println("创建成功");}else{System.out.println("创建失败");}}
}
2.单个文件夹查找文件
package a03_File综合练习;import java.io.File;public class a02_单个文件夹查找文件 {public static void main(String[] args) {/*需求：定义一个方法找某一个文件夹中，是否有以avi结尾的电影。（暂时不需要考虑子文件夹）*/File file = new File("D:\\aaa\\bbb");boolean b = haveAVI(file);System.out.println(b);}/** 作用：用来找某一个文件夹中，是否有以avi结尾的电影* 形参：要查找的文件夹* 返回值：查找的结果 存在true 不存在false* */public static boolean haveAVI(File file){// D:\\aaa//1.进入aaa文件夹，而且要获取里面所有的内容File[] files = file.listFiles();//2.遍历数组获取里面的每一个元素for (File f : files) {//f：依次表示aaa文件夹里面每一个文件或者文件夹的路径if(f.isFile() && f.getName().endsWith(".avi")){return true;}}//3.如果循环结束之后还没有找到，直接返回falsereturn false;}
}
3.遍历硬盘查找文件
package a03_File综合练习;import java.io.File;public class a03_遍历硬盘查找文件 {public static void main(String[] args) {/* 需求：找到电脑中所有以avi结尾的电影。（需要考虑子文件夹）套路：1，进入文件夹2，遍历数组3，判断4，判断*/findAVI();}public static void findAVI(){//获取本地所有的盘符File[] arr = File.listRoots();for (File f : arr) {findAVI(f);}}public static void findAVI(File src){ // "C:\\//1.进入文件夹srcFile[] files = src.listFiles();//2.遍历数组,依次得到src里面每一个文件或者文件夹if(files != null){for (File file : files) {if(file.isFile()){//3，判断，如果是文件，就可以执行题目的业务逻辑String name = file.getName();if(name.endsWith(".avi")){System.out.println(file);}}else{//4，判断，如果是文件夹，就可以递归//细节：再次调用本方法的时候，参数一定要是src的次一级路径findAVI(file);}}}}
}
4.删除文件夹
package a03_File综合练习;import java.io.File;public class a04_删除文件夹 {public static void main(String[] args) {/*删除一个多级文件夹如果我们要删除一个有内容的文件夹1. 先删除文件夹里面所有的内容2. 再删除自己*/File file = new File("D:\\aaa\\src");delete(file);}/** 作用：删除src文件夹* 参数：要删除的文件夹*/public static void delete(File src){//1.先删除文件夹里面所有的内容//进入srcFile[] files = src.listFiles();//遍历for (File file : files) {//判断,如果是文件，删除if(file.isFile()){file.delete();}else {//判断,如果是文件夹，就递归delete(file);}}//2.再删除自己src.delete();}
}
5.统计文件夹大小
package a03_File综合练习;import java.io.File;public class a05_统计一个文件夹的总大小 {public static void main(String[] args) {/*需求：统计一个文件夹的总大小*/File file = new File("D:\\aaa\\src");long len = getLen(file);System.out.println(len);}/** 作用：* 统计一个文件夹的总大小* 参数：* 表示要统计的那个文件夹* 返回值：* 统计之后的结果** 文件夹的总大小：* 说白了，文件夹里面所有文件的大小*/public static long getLen(File src){//1.定义变量进行累加long len = 0;//2.进入src文件夹File[] files = src.listFiles();//3.遍历数组for (File file : files) {//4.判断if(file.isFile()){//我们就把当前文件的大小累加到len当中len = len + file.length();}else{//判断，如果是文件夹就递归len = len + getLen(file);}}return len;}
}
6.统计各种文件数量
package a03_File综合练习;import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class a06_统计各种文件数量 {public static void main(String[] args) {/*需求：统计一个文件夹中每种文件的个数并打印。（考虑子文件夹）打印格式如下：txt:3个doc:4个jpg:6个*/File file = new File("D:\\aaa\\src");HashMap<String, Integer> hm = getCount(file);System.out.println(hm);}/** 作用：* 统计一个文件夹中每种文件的个数* 参数：* 要统计的那个文件夹* 返回值：* 用来统计map集合* 键：后缀名 值：次数** a.txt* a.a.txt* aaa（不需要统计的）**/public static HashMap<String, Integer> getCount(File src) {//1.定义集合用来统计HashMap<String, Integer> hm = new HashMap<>();//2.进入src文件夹File[] files = src.listFiles();//3.遍历数组for (File file : files) {//4.判断，如果是文件，统计if (file.isFile()) {//a.txtString name = file.getName();String[] arr = name.split("\\.");if (arr.length >= 2) {String endName = arr[arr.length - 1];if (hm.containsKey(endName)) {//存在int count = hm.get(endName);count++;hm.put(endName, count);} else {//不存在hm.put(endName, 1);}}} else {//5.判断，如果是文件夹，递归//sonMap里面是子文件中每一种文件的个数HashMap<String, Integer> sonMap = getCount(file);//hm: txt=1 jpg=2 doc=3//sonMap: txt=3 jpg=1//遍历sonMap把里面的值累加到hm当中Set<Map.Entry<String, Integer>> entries = sonMap.entrySet();for (Map.Entry<String, Integer> entry : entries) {String key = entry.getKey();int value = entry.getValue();if (hm.containsKey(key)) {//存在int count = hm.get(key);count = count + value;hm.put(key, count);} else {//不存在hm.put(key, value);}}}}return hm;}
}
IO流
1.IO流的概述
1.什么是 IO 流？存储和读取数据的解决方案I: input O: output流：像水流一样传输数据 2.IO 流的作用？用于读写数据（本地文件，网络） 3.IO 流按照流向可以分类哪两种流？输出流：程序 → 文件输入流：文件 → 程序 4.IO 流按照操作文件的类型可以分类哪两种流？字节流：可以操作所有类型的文件字符流：只能操作纯文本文件 5.什么是纯文本文件？用 windows 系统自带的记事本打开并且能读懂的文件txt 文件，md 文件，xml 文件，lrc 文件等
2.IO流的体系和字节输出流基本用法
IO 流体系字节流 InputStream（字节输入流） OutputStream（字节输出流）字符流Reader（字符输入流）Writer（字符输出流）
package a02_IO流的体系和字节输出流基本用法;import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {/** 演示：字节输出流FileOutputStream* 实现需求：写出一段文字到本地文件中。（暂时不写中文）** 实现步骤：* 创建对象* 写出数据* 释放资源* *///1.创建对象//写出 输出流 OutputStream//本地文件 FileFileOutputStream fos = new FileOutputStream("a23_IO流\\a.txt");//2.写出数据fos.write(97);//3.释放资源fos.close();}
}
3.字节输出流写出数据的细节
字节输出流的细节：1.创建字节输出流对象细节1：参数是字符串表示的路径或者是File对象都是可以的细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。细节3：如果文件已经存在，则会清空文件2.写数据细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符'9''7'3.释放资源每次使用完流之后都要释放资源
//1.创建对象
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
//2.写出数据
fos.write(57);
fos.write(55);
//3.释放资源
fos.close();while(true){}
4.字节输出流写出数据的三种方式
void write (int b) 一次写一个字节数据 void write (byte [] b) 一次写一个字节数组数据 void write (byte [] b, int off, int len) 一次写一个字节数组的部分数据 参数一：数组 参数二：起始索引 参数三：个数
//1.创建对象
FileOutputStream fos = new FileOutputStream("a23_IO流\\a.txt");
//2.写出数据
//fos.write(97); // a
//fos.write(98); // bbyte[] bytes = {97, 98, 99, 100, 101};
/* fos.write(bytes);*/fos.write(bytes, 1, 2);// b c//3.释放资源
fos.close();
5.换行和续写
换行写：再次写出一个换行符就可以了windows: \r\nLinux: \nMac: \r 细节：在 windows 操作系统当中，java 对回车换行进行了优化。虽然完整的是 \r\n，但是我们写其中一个 \r 或者 \n，java 也可以实现换行，因为 java 在底层会补全。 建议：不要省略，还是写全了。续写：如果想要续写，打开续写开关即可开关位置：创建对象的第二个参数默认 false：表示关闭续写，此时创建对象会清空文件手动传递 true：表示打开续写，此时创建对象不会清空文件
//1.创建对象
FileOutputStream fos = new FileOutputStream("a23_IO流\\a.txt", true);
//2.写出数据
String str = "kankelaoyezuishuai";
byte[] bytes1 = str.getBytes();
fos.write(bytes1);//再次写出一个换行符就可以了
String wrap = "\r\n";
byte[] bytes2 = wrap.getBytes();
fos.write(bytes2);String str2 = "666";
byte[] bytes3 = str2.getBytes();
fos.write(bytes3);//3.释放资源
fos.close();
总结： 1.FileOutputStream 的作用可以把程序中的数据写到本地文件上，是字节流的基本流。 2.书写步骤创建对象，写出数据，释放资源 3.三步操作的细节创建对象：文件存在、文件不存在、追加写入写出数据：写出整数、写出字节数组、换行写释放资源：关闭通道
6.字节输入流的基本用法
package a06_字节输入流的基本用法;import java.io.FileInputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {/*演示：字节输入流FileInputStream实现需求：读取文件中的数据abcde。（暂时不写中文）实现步骤：创建对象读取数据释放资源*///1.创建对象FileInputStream fis = new FileInputStream("a23_IO流\\a.txt");//2.读取数据int b1 = fis.read();System.out.println((char)b1);int b2 = fis.read();System.out.println((char)b2);int b3 = fis.read();System.out.println((char)b3);int b4 = fis.read();System.out.println((char)b4);int b5 = fis.read();System.out.println((char)b5);int b6 = fis.read();System.out.println(b6);//-1//3.释放资源fis.close();}
}
7.字节输入流读取数据的细节
字节输入流的细节：1.创建字节输入流对象细节1：如果文件不存在，就直接报错。Java为什么会这么设计呢？输出流：不存在，创建把数据写到文件当中输入流：不存在，而是报错呢？因为创建出来的文件是没有数据的，没有任何意义。所以Java就没有设计这种无意义的逻辑，文件不存在直接报错。程序中最重要的是：数据。2.写数据细节1：一次读一个字节，读出来的是数据在ASCII上对应的数字细节2：读到文件末尾了，read方法返回-1。3.释放资源细节：每次使用完流之后都要释放资源
//1.创建对象
FileInputStream fis = new FileInputStream("a23_IO流\\b.txt");
//2.读取数据
int b1 = fis.read();
System.out.println((char)b1);
//3.释放资源
fis.close();
8.字节输入流循环读取
// 字节输入流循环读取//1.创建对象FileInputStream fis = new FileInputStream("a23_IO流\\a.txt");//2.循环读取int b;while((b = fis.read()) != -1){System.out.print((char)b);}//3.释放资源fis.close();
9.文件拷贝的基本代码
package a09_文件拷贝的基本代码;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {
// 练习：
// 文件拷贝
// 把 D:\itheima\movie.mp4 拷贝到当前模块下。
// 注意：
// 选择一个比较小的文件，不要太大。大文件拷贝我们下一个视频会说。//1.创建对象FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");FileOutputStream fos = new FileOutputStream("a23_IO流\\copy.mp4");//2.拷贝//核心思想：边读边写int b;while((b = fis.read()) != -1){fos.write(b);}//3.释放资源//规则：先开的最后关闭fos.close();fis.close();}
}
10.文件拷贝的弊端和解决方案
一次读一个字节太慢了 FileInputStream 一次读多个字节 方法名称 说明 public int read() 一次读一个字节数据 public int read(byte[] buffer) 一次读一个字节数组数据 注意：一次读一个字节数组的数据，每次读取会尽可能把数组装满 1024 的整数倍 1024 * 1024 * 5
//1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.读取数据
byte[] bytes = new byte[2];
//一次读取多个字节数据，具体读多少，跟数组的长度有关
//返回值：本次读取到了多少个字节数据
int len1 = fis.read(bytes);
System.out.println(len1);//2
String str1 = new String(bytes, 0,len1); // 读bytes 从0索引开始 读len1个
System.out.println(str1);int len2 = fis.read(bytes);
System.out.println(len2);//2
String str2 = new String(bytes, 0,len2); // 读bytes 从0索引开始 读len2个
System.out.println(str2);int len3 = fis.read(bytes);
System.out.println(len3);// 1
String str3 = new String(bytes, 0,len3); // 读bytes 从0索引开始 读len3个
System.out.println(str3);// e//3.释放资源
fis.close();
11.文件拷贝改写
package a11_文件拷贝改写;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test {public static void main(String[] args) throws IOException {/*练习：文件拷贝把D:\itheima\movie.mp4 (16.8 MB) 拷贝到当前模块下。*///1.创建对象FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");//2.拷贝int len;byte[] bytes = new byte[1024 * 1024 * 5];while((len = fis.read(bytes)) != -1){fos.write(bytes, 0,len);}//3.释放资源fos.close();fis.close();}
}
12.IO流中不同JDK版本捕获异常的方式
自己写
package a12_IO流中不同JDK版本捕获异常的方式;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class a01_自己写 {public static void main(String[] args) {//利用 try...catch...finally 捕获拷贝文件中代码出现的异常//1.创建对象FileInputStream fis = null;FileOutputStream fos = null;try {fis = new FileInputStream("D:\\itheima\\movie.mp4");fos = new FileOutputStream("myio\\copy.mp4");//2.拷贝int len;byte[] bytes = new byte[1024 * 1024 * 5];while ((len = fis.read(bytes)) != -1) {fos.write(bytes, 0, len);}} catch (IOException e) {//e.printStackTrace();} finally {//3.释放资源if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}
JDK7
IO 流中捕获异常的写法
try 后面的小括号中写创建对象的代码，只有实现了 AutoCloseable 接口的类，才能在小括号中创建对象。
try (){
}catch(){
}
package a12_IO流中不同JDK版本捕获异常的方式;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class a02_JDK7 {public static void main(String[] args) {try (FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");FileOutputStream fos = new FileOutputStream("myio\\copy.mp4")) {//2.拷贝int len;byte[] bytes = new byte[1024 * 1024 * 5];while ((len = fis.read(bytes)) != -1) {fos.write(bytes, 0, len);}} catch (IOException e) {e.printStackTrace();}}
}
JDK9
package a12_IO流中不同JDK版本捕获异常的方式;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class a03_JDK9 {public static void main(String[] args) throws FileNotFoundException {// JDK9:IO流中捕获异常的写法FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");try (fis;fos) {//2.拷贝int len;byte[] bytes = new byte[1024 * 1024 * 5];while ((len = fis.read(bytes)) != -1) {fos.write(bytes, 0, len);}} catch (IOException e) {e.printStackTrace();}}
}
13.字符集详解
ASCII和GBK
在计算机中，任意数据都是以二进制的形式来存储的 计算机中最小的存储单元是一个字节 ASCII 字符集中，一个英文占一个字节 简体中文版 Windows，默认使用 GBK 字符集 GBK 字符集完全兼容 ASCII 字符集 一个英文占一个字节，二进制第一位是 0 一个中文占两个字节，二进制高位字节的第一位是 1
Unicode
Unicode 字符集的 UTF-8 编码格式一个英文占一个字节，二进制第一位是 0，转成十进制是正数一个中文占三个字节，二进制第一位是 1，第一个字节转成十进制是负数
14.为什么会有乱码
为什么会有乱码？原因1：读取数据时未读完整汉字原因2：编码和解码时的方式不统一如何不产生乱码？不要用字节流读取文本文件编码解码时使用同一个码表，同一个编码方式
15.Java中编码和解码的代码实现
Java中编码的方法String类中的方法 说明public byte[] getBytes() 使用默认方式进行编码public byte[] getBytes(String charsetName) 使用指定方式进行编码 Java中解码的方法String类中的方法 说明String(byte[] bytes) 使用默认方式进行解码String(byte[] bytes, String charsetName) 使用指定方式进行解码
//1.编码
String str = "ai你哟";
byte[] bytes1 = str.getBytes();
System.out.println(Arrays.toString(bytes1));byte[] bytes2 = str.getBytes("GBK");
System.out.println(Arrays.toString(bytes2));//2.解码
String str2 = new String(bytes1);
System.out.println(str2);String str3 = new String(bytes1, "GBK");
System.out.println(str3);
16.字符输入流
空参read方法详解
字符流字符流的底层其实就是字节流字符流 = 字节流 + 字符集 特点输入流：一次读一个字节，遇到中文时，一次读多个字节输出流：底层会把数据按照指定的编码方式进行编码，变成字节再写到文件中 使用场景对于纯文本文件进行读写操作
read（）细节： 1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个 2.在读取之后，方法的底层还会进行解码并转成十进制。最终把这个十进制作为返回值这个十进制的数据也表示在字符集上的数字英文：文件里面二进制数据 0110 0001read方法进行读取，解码并转成十进制97中文：文件里面的二进制数据 1100110 10110001 10001001read方法进行读取，解码并转成十进制27721我想看到中文汉字，就是把这些十进制数据，再进行强转就可以了
//1.创建对象并关联本地文件
FileReader fr = new FileReader("myio\\a.txt");
//2.读取数据 read()
//字符流的底层也是字节流，默认也是一个字节一个字节的读取的。
//如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节
int ch;
while((ch = fr.read()) != -1){System.out.print((char)ch);
}//3.释放资源
fr.close();
有参read方法详解
第一步：创建对象 public FileReader(File file) 创建字符输入流关联本地文件 public FileReader(String pathname) 创建字符输入流关联本地文件第二步：读取数据 public int read() 读取数据，读到末尾返回-1 public int read(char[] buffer) 读取多个数据，读到末尾返回-1第三步：释放资源 public void close() 释放资源/关流
//1.创建对象
FileReader fr = new FileReader("myio\\a.txt");
//2.读取数据
char[] chars = new char[2];
int len;
//read(chars)：读取数据，解码，强转三步合并了，把强转之后的字符放到数组当中
//空参的read + 强转类型转换
while((len = fr.read(chars)) != -1){//把数组中的数据变成字符串再进行打印System.out.print(new String(chars, 0,len));
}
//3.释放资源
fr.close();
17.字符输出流写出数据
FileWriter 构造方法 构造方法 说明 public FileWriter(File file) 创建字符输出流关联本地文件 public FileWriter(String pathname) 创建字符输出流关联本地文件 public FileWriter(File file, boolean append) 创建字符输出流关联本地文件，续写 public FileWriter(String pathname, boolean append) 创建字符输出流关联本地文件，续写成员方法 说明 void write(int c) 写出一个字符 void write(String str) 写出一个字符串 void write(String str, int off, int len) 写出一个字符串的一部分 void write(char[] cbuf) 写出一个字符数组 void write(char[] cbuf, int off, int len) 写出字符数组的一部分
FileWriter fw = new FileWriter("myio\\a.txt", true);//fw.write(25105);
//fw.write("你好威啊???");
char[] chars = {'a','b','c','我'};
fw.write(chars);fw.close();
18.字符输入流的底层原理超详解
字符流原理解析 ①创建字符输入流对象底层：关联文件，并创建缓冲区（长度为 8192 的字节数组） ②读取数据底层：1.判断缓冲区中是否有数据可以读取2.缓冲区没有数据：就从文件中获取数据，装到缓冲区中，每次尽可能装满缓冲区如果文件中也没有数据了，返回-13.缓冲区有数据：就从缓冲区中读取。空参的 read 方法：一次读取一个字节，遇到中文一次读多个字节，把字节解码并转成十进制返回有参的 read 方法：把读取字节，解码，强转三步合并了，强转之后的字符放到数组中
19.字符输出流的底层原理超详解
flush 和 close 方法 成员方法 说明 public void flush() 将缓冲区中的数据，刷新到本地文件中 public void close() 释放资源 / 关流 flush 刷新：刷新之后，还可以继续往文件中写出数据 close 关流：断开通道，无法再往文件中写出数据
20.综合练习
拷贝文件夹
package a20_综合练习;import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class a01_拷贝文件夹 {public static void main(String[] args) throws IOException {//拷贝一个文件夹，考虑子文件夹//1.创建对象表示数据源File src = new File("D:\\aaa\\src");//2.创建对象表示目的地File dest = new File("D:\\aaa\\dest");//3.调用方法开始拷贝copydir(src, dest);}/** 作用：拷贝文件夹* 参数一：数据源* 参数二：目的地**/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()));}}}
}
加密和解密文件
package a20_综合练习;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class a02_加密和解密文件 {public static void main(String[] args) throws IOException {
// 为了保证文件的安全性，就需要对原始文件进行加密存储，再使用的时候再对其进行解密处理。
// 加密原理：
// 对原始文件中的每一个字节数据进行更改，然后将更改以后的数据存储到新的文件中。
// 解密原理：
// 读取加密之后的文件，按照加密的规则反向操作，变成原始文件。
// ^ ：异或
// 两边相同：false
// 两边不同：true
// 一个数异或两次同一个数 得到自身//1.创建对象关联原始文件FileInputStream fis = new FileInputStream("myio\\girl.jpg");//2.创建对象关联加密文件FileOutputStream fos = new FileOutputStream("myio\\ency.jpg");//3.加密处理int b;while((b = fis.read()) != -1){fos.write(b ^ 2);}//4.释放资源fos.close();fis.close();}
}
修改文件中的数据
package a20_综合练习;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;public class a03_修改文件中的数据 {public static void main(String[] args) throws IOException {
// 文本文件中有以下的数据：
// 2-1-9-4-7-8
// 将文件中的数据进行排序，变成以下的数据：
// 1-2-4-7-8-9//1.读取数据FileReader fr = new FileReader("a23_IO流\\a.txt");StringBuilder sb = new StringBuilder();int ch;while((ch = fr.read()) != -1){sb.append((char)ch);}fr.close();System.out.println(sb);//2.排序
// String str = sb.toString();
// String[] arrStr = str.split("-");//2-1-9-4-7-8
//
// ArrayList<Integer> list = new ArrayList<>();
// for (String s : arrStr) {
// int i = Integer.parseInt(s);
// list.add(i);
// }
// Collections.sort(list);
// System.out.println(list);//简化写法Integer[] arr = Arrays.stream(sb.toString().split("-")).map(Integer::parseInt).sorted().toArray(Integer[]::new);System.out.println(Arrays.toString(arr));//3.写出
// FileWriter fw = new FileWriter("myio\\a.txt");
// for (int i = 0; i < list.size(); i++) {
// if(i == list.size() - 1){
// fw.write(list.get(i) + "");
// }else{
// fw.write(list.get(i) + "-");
// }
// }
// fw.close();//简化写法FileWriter fw = new FileWriter("a23_IO流\\a.txt");String s = Arrays.toString(arr).replace(",", "-");String result = s.substring(1, s.length() - 1);fw.write(result);fw.close();}
}
21.字节缓冲流拷贝文件
一次读写一个字节
缓冲流字节缓冲流BufferedInputStream（字节缓冲输入流）BufferedOutputStream（字节缓冲输出流）字符缓冲流BufferedReader（字符缓冲输入流）BufferedWriter（字符缓冲输出流） 原理：底层自带了长度为 8192 的缓冲区提高性能字节缓冲流 方法名称 说明 public BufferedInputStream(InputStream is) 把基本流包装成高级流，提高读取数据的性能 public BufferedOutputStream(OutputStream os) 把基本流包装成高级流，提高写出数据的性能
package a21_字节缓冲流拷贝文件;import java.io.*;public class a01_一次读写一个字节 {public static void main(String[] args) throws IOException {//1.创建缓冲流的对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myio\\a.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();}
}
一次读写一个字节数组
package a21_字节缓冲流拷贝文件;import java.io.*;public class a02_一次读写一个字节数组 {public static void main(String[] args) throws IOException {/*需求:利用字节缓冲流拷贝文件字节缓冲输入流的构造方法:public BufferedInputStream(InputStream is)字节缓冲输出流的构造方法:public BufferedOutputStream(OutputStream os)*///1.创建缓冲流的对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myio\\a.txt"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\copy2.txt"));//2.拷贝（一次读写多个字节）byte[] bytes = new byte[1024];int len;while((len = bis.read(bytes)) != -1){bos.write(bytes, 0,len);}//3.释放资源bos.close();bis.close();}
}
22.字符缓冲流
字符缓冲流BufferedReader（字符缓冲输入流）BufferedWriter（字符缓冲输出流） 原理：底层自带了长度为 8192 的缓冲区提高性能字符缓冲流的构造方法 方法名称 说明 public BufferedReader(Reader r) 把基本流变成高级流 public BufferedWriter(Writer r) 把基本流变成高级流字符缓冲流特有方法 字符缓冲输入流特有方法 说明 public String readLine() 读取一行数据，如果没有数据可读了，会返回 null 字符缓冲输出流特有方法 说明 public void newLine() 跨平台的换行 Mac: \r Linux: \n Windows: \r\n
//1.创建字符缓冲输入流的对象BufferedReader br = new BufferedReader(new FileReader("myio\\a.txt"));//2.读取数据//细节：//readLine方法在读取的时候，一次读一整行，遇到回车换行结束// 但是他不会把回车换行读到内存当中
// String line1 = br.readLine();
// System.out.println(line1);
//
// String line2 = br.readLine();
// System.out.println(line2);//循环写法String line;while ((line = br.readLine()) != null){System.out.println(line);}//3.释放资源br.close();
//1.创建字符缓冲输出流的对象
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt", true));
//2.写出数据
bw.write("你嘴角上扬的样子，百度搜索不到");
bw.newLine();
bw.write("以后如果我结婚了，你一定要来哦，没有新娘我会很尴尬");
bw.newLine();
//3.释放资源
bw.close();
缓冲流总结: 1.缓冲流有几种？字节缓冲输入流: BufferedInputStream字节缓冲输出流: BufferedOutputStream字符缓冲输入流: BufferedReader字符缓冲输出流: BufferedWriter 2.缓冲流为什么能提高性能？缓冲流自带长度为 8192 的缓冲区可以显著提高字节流的读写性能对于字符流提升不明显，对于字符缓冲流而言关键点是两个特有的方法 3.字符缓冲流两个特有的方法是什么？字符缓冲输入流 BufferedReader: readLine ()字符缓冲输出流 BufferedWriter: newLine ()
23.综合练习
四种拷贝方式效率对比
package a23_综合练习;import java.io.*;public class a01_四种拷贝方式效率对比 {public static void main(String[] args) throws IOException {/*四种方式拷贝文件，并统计各自用时*/long start = System.currentTimeMillis();//method1();//method2(); //16.253秒//method3(); //95.466秒//method4(); //17.686秒long end = System.currentTimeMillis();System.out.println((end - start) / 1000.0 + "秒");}//字节流的基本流：一次读写一个字节4,588,568,576 字节public static void method1() throws IOException {FileInputStream fis = new FileInputStream("E:\\aaa\\CentOS-7-x86_64-DVD-1810.iso");FileOutputStream fos = new FileOutputStream("myio\\copy.iso");int b;while ((b = fis.read()) != -1) {fos.write(b);}fos.close();fis.close();}//字节流的基本流：一次读写一个字节数组public static void method2() throws IOException {FileInputStream fis = new FileInputStream("E:\\aaa\\CentOS-7-x86_64-DVD-1810.iso");FileOutputStream fos = new FileOutputStream("myio\\copy.iso");byte[] bytes = new byte[8192];int len;while ((len = fis.read(bytes)) != -1) {fos.write(bytes, 0, len);}fos.close();fis.close();}//字节流的基本流：一次读写一个字节数组public static void method3() throws IOException {BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\aaa\\CentOS-7-x86_64-DVD-1810.iso"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\copy.iso"));int b;while ((b = bis.read()) != -1) {bos.write(b);}bos.close();bis.close();}//字节流的基本流：一次读写一个字节数组public static void method4() throws IOException {BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\aaa\\CentOS-7-x86_64-DVD-1810.iso"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\copy.iso"));byte[] bytes = new byte[8192];int len;while ((len = bis.read(bytes)) != -1) {bos.write(bytes, 0, len);}bos.close();bis.close();}
}
恢复出师表的顺序(第一种实现方法)
package a23_综合练习;import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class a02_恢复出师表的顺序 {public static void main(String[] args) throws IOException {/*3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏。4.将军向宠，性行淑均，晓畅军事，试用于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以9.今当远离，临表涕零，不知所言。6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐托付不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节需求: 把《出师表》的文章顺序进行恢复到一个新文件中。*///1.读取数据BufferedReader br = new BufferedReader(new FileReader("myio\\csb.txt"));String line;ArrayList<String> list = new ArrayList<>();while((line = br.readLine()) != null){list.add(line);}br.close();//2.排序//排序规则: 按照每一行前面的序号进行排列Collections.sort(list, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {//获取o1和o2的序号int i1 = Integer.parseInt(o1.split("\\.")[0]);int i2 = Integer.parseInt(o2.split("\\.")[0]);return i1 - i2;//1 2 3 4 56 ...}});//3.写出BufferedWriter bw = new BufferedWriter(new FileWriter("myio\\result.txt"));for (String str : list) {bw.write(str);bw.newLine();}bw.close();}
}
恢复出师表的顺序(第二种实现方法)
package a23_综合练习;import java.io.*;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;public class a02_恢复出师表的顺序第二种实现方法 {public static void main(String[] args) throws IOException {/*需求: 把《出师表》的文章顺序进行恢复到一个新文件中。*///1.读取数据BufferedReader br = new BufferedReader(new FileReader("myio\\csb.txt"));String line;TreeMap<Integer, String> tm = new TreeMap<>();while ((line = br.readLine()) != null) {String[] arr = line.split("\\.");//0: 序号 1 : 内容tm.put(Integer.parseInt(arr[0]), arr[1]);}br.close();//2.写出数据BufferedWriter bw = new BufferedWriter(new FileWriter("myio\\result2.txt"));Set<Map.Entry<Integer, String>> entries = tm.entrySet();for (Map.Entry<Integer, String> entry : entries) {String value = entry.getValue();bw.write(value);bw.newLine();}bw.close();}
}
控制软件运行次数
package a23_综合练习;import java.io.*;public class a03_控制软件运行次数 {public static void main(String[] args) throws IOException {/*实现一个验证程序运行次数的小程序，要求如下：1. 当程序运行超过 3 次时给出提示：本软件只能免费使用 3 次，欢迎您注册会员后继续使用～2. 程序运行演示如下:第一次运行控制台输出：欢迎使用本软件，第 1 次使用免费～第二次运行控制台输出：欢迎使用本软件，第 2 次使用免费～第三次运行控制台输出：欢迎使用本软件，第 3 次使用免费～第四次及之后运行控制台输出：本软件只能免费使用 3 次，欢迎您注册会员后继续使用～*///1.把文件中的数字读取到内存中// 原则://IO: 随用随创建// 什么时候不用什么时候关闭BufferedReader br = new BufferedReader(new FileReader("myio\\count.txt"));String line = br.readLine();br.close();int count = Integer.parseInt(line);//表示当前软件又运行了一次count++;//1//2.判断if(count <= 3){System.out.println("欢迎使用本软件,第"+count+"次使用免费~");}else{System.out.println("本软件只能免费使用3次,欢迎您注册会员后继续使用~");}//3.把当前自增之后的count写出到文件当中BufferedWriter bw = new BufferedWriter(new FileWriter("myio\\count.txt"));bw.write(count + ""); //97 + ""bw.close();}
}
24.转换流基本用法
利用转换流按照指定字符编码读取
package a24_转换流基本用法;import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.Charset;public class Test1 {public static void main(String[] args) throws IOException {/*利用转换流按照指定字符编码读取 (了解)因为 JDK11：这种方式被淘汰了。替代方案 (掌握)F:\JavaSE最新版\day29-IO（其他流）\资料\gbkfile.txt*/// //1.创建对象并指定字符编码
// InputStreamReader isr = new InputStreamReader(new FileInputStream("myio\\gbkfile.txt"), "GBK");
// //2.读取数据
// int ch;
// while ((ch = isr.read()) != -1){
// System.out.println((char)ch);
// }
// //3.释放资源
// isr.close();//替代方案FileReader fr = new FileReader("myio\\gbkfile.txt", Charset.forName("GBK"));//2.读取数据int ch;while ((ch = fr.read()) != -1){System.out.print((char)ch);}//3.释放资源fr.close();}
}
利用转换流按照指定字符编码写出
package a24_转换流基本用法;import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;public class a02_利用转换流按照指定字符编码写出 {public static void main(String[] args) throws IOException {/*利用转换流按照指定字符编码写出*/// //1.创建转换流的对象
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a23_IO流\\b.txt"), "GBK");
// //2.写出数据
// osw.write("你好你好");
// //3.释放资源
// osw.close();//替代方案FileWriter fw = new FileWriter("a23_IO流\\c.txt", Charset.forName("GBK"));fw.write("你好你好");fw.close();}
}
将本地文件中的GBK文件转成UTF-8
package a24_转换流基本用法;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;public class a03_将本地文件中的GBK文件转成UTF8 {public static void main(String[] args) throws IOException {/*将本地文件中的GBK文件，转成UTF-8*///1.JDK11以前的方案
// InputStreamReader isr = new InputStreamReader(new FileInputStream("a23_IO流\\b.txt"), "GBK");
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a23_IO流\\d.txt"), "UTF-8");
// int b;
// while((b = isr.read()) != -1){
// osw.write(b);
// }
// osw.close();
// isr.close();//2.替代方案FileReader fr = new FileReader("a23_IO流\\b.txt", Charset.forName("GBK"));FileWriter fw = new FileWriter("a23_IO流\\e.txt",Charset.forName("UTF-8"));int b;while ((b = fr.read()) != -1){fw.write(b);}fw.close();fr.close();}
}
25.转换流练习
package a25_转换流练习;import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;public class Test {public static void main(String[] args) throws IOException {/*利用字节流读取文件中的数据，每次读一整行，而且不能出现乱码//1.字节流在读取中文的时候，是会出现乱码的，但是字符流可以搞定//2.字节流里面是没有读一整行的方法的，只有字符缓冲流才能搞定*//*FileInputStream fis = new FileInputStream("myio\\a.txt");InputStreamReader isr = new InputStreamReader(fis);BufferedReader br = new BufferedReader(isr);String str = br.readLine();System.out.println(str);br.close();*/BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("myio\\a.txt")));String line;while ((line = br.readLine()) != null){System.out.println(line);}br.close();}
}
26.序列化流
序列化流 / 对象操作输出流 可以把Java中的 对象 写到本地文件中 构造方法 说明 public ObjectOutputStream(OutputStream out) 把基本流包装成高级流 成员方法 说明 public final void writeObject(Object obj) 把对象序列化（写出）到文件中去序列化流的小细节使用对象输出流将对象保存到文件时会出现NotSerializableException异常 解决方案：需要让Javabean类实现 Serializable 接口
package a26_序列化流;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;public class Test {public static void main(String[] args) throws IOException {//1.创建对象Student stu = new Student("zhangsan", 23);//2.创建序列化流的对象/对象操作输出流ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myio\\a.txt"));//3.写出数据oos.writeObject(stu);//4.释放资源oos.close();}
}
package a26_序列化流;import java.io.Serializable;//Serializable接口里面没有抽象方法，属于标记型接口
//一旦实现了这个接口，那么就表示当前的Student类可以被序列化
//理解：一个物品的合格证
public class Student implements Serializable {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}
27.反序列化流
反序列化流 / 对象操作输入流 可以把序列化到本地文件中的对象，读取到程序中来 构造方法 说明 public ObjectInputStream(InputStream out) 把基本流变成高级流 成员方法 说明 public Object readObject() 把序列化到本地文件中的对象，读取到程序中来
//1.创建反序列化流的对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myio\\a.txt"));//2.读取数据
Student o = (Student) ois.readObject();//3.打印对象
System.out.println(o);//4.释放资源
ois.close();
28.序列化流和反序列化流的使用细节
序列化流 / 反序列化流的细节汇总 1.使用序列化流将对象写到文件时，需要让 Javabean 类实现Serializable接口。否则，会出现NotSerializableException异常 2.序列化流写到文件中的数据是不能修改的，一旦修改就无法再次读回来了 3.序列化对象后，修改了 Javabean 类，再次反序列化，会不会有问题？会出问题，会抛出InvalidClassException异常解决方案：给 Javabean 类添加serialVersionUID（序列号、版本号） 4.如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？解决方案：给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程
package a28_序列化流和反序列化流的使用细节;import java.io.Serializable;public class Student implements Serializable {private static final long serialVersionUID = -4542404533081631212L;private String name;private int age;//transient: 瞬态关键字//作用：不会把当前属性序列化到本地文件当中private transient String address;
}
29_综合练习(读写多个对象)
package a29_综合练习_读写多个对象;import java.io.Serial;
import java.io.Serializable;public class Student implements Serializable {@Serialprivate static final long serialVersionUID = 1206624823229955318L;private String name;private int age;private String address;public Student() {}public Student(String name, int age, String address) {this.name = name;this.age = age;this.address = address;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}
}
package a29_综合练习_读写多个对象;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;public class Test {public static void main(String[] args) throws IOException {/*需求：将多个自定义对象序列化到文件中，但是对象的个数不确定，该如何操作呢？*///1.序列化多个对象Student s1 = new Student("zhangsan", 23, "南京");Student s2 = new Student("lisi", 24, "重庆");Student s3 = new Student("wangwu", 25, "北京");ArrayList<Student> list = new ArrayList<>();list.add(s1);list.add(s2);list.add(s3);ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myio\\a.txt"));oos.writeObject(list);oos.close();}
}
package a29_综合练习_读写多个对象;import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;public class Test2 {public static void main(String[] args) throws IOException, ClassNotFoundException {//1.创建反序列化流的对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myio\\a.txt"));//2.读取数据ArrayList<Student> list = (ArrayList<Student>) ois.readObject();for (Student student : list) {System.out.println(student);}//3.释放资源ois.close();}
}
30_字节打印流
打印流 分类：打印流一般是指：PrintStream，PrintWriter两个类 特点1：打印流只操作文件目的地，不操作数据源 特点2：特有的写出方法可以实现，数据原样写出例如：打印：97 文件中：97打印：true 文件中：true 特点3：特有的写出方法，可以实现自动刷新，自动换行打印一次数据 = 写出 + 换行 + 刷新字节打印流 构造方法 说明 public PrintStream(OutputStream/File/String) 关联字节输出流 / 文件 / 文件路径 public PrintStream(String fileName, Charset charset) 指定字符编码 public PrintStream(OutputStream out, boolean autoFlush) 自动刷新 字节流底层没有缓冲区，开不开自动刷新都一样 public PrintStream(OutputStream out, boolean autoFlush, String encoding) 指定字符编码且自动刷新成员方法 说明 public void write(int b) 常规方法：规则跟之前一样，将指定的字节写出 public void println(Xxx xx) 特有方法：打印任意数据，自动刷新，自动换行 数据原样写出 public void print(Xxx xx) 特有方法：打印任意数据，不换行 数据原样写出 public void printf(String format, Object... args) 特有方法：带有占位符的打印语句，不换行 数据原样写出
//1.创建字节打印流的对象
PrintStream ps = new PrintStream(new FileOutputStream("myio\\a.txt"), true, Charset.forName("UTF-8"));
//2.写出数据
ps.println(97);//写出 + 自动刷新 + 自动换行
ps.print(true);
ps.println();
ps.printf("%s爱上了%s","阿珍","阿强");
//3.释放资源
ps.close();
31.字符打印流
字符打印流 构造方法 说明 public PrintWriter(Write/File/String) 关联字节输出流 / 文件 / 文件路径 public PrintWriter(String fileName, Charset charset) 指定字符编码 public PrintWriter(Write w, boolean autoFlush) 自动刷新 字符流底层有缓冲区，想要自动刷新需要开启 public PrintWriter(OutputStream out, boolean autoFlush, Charset charset) 指定字符编码且自动刷新成员方法 说明 public void write(...) 常规方法：规则跟之前一样，写出字节或者字符串 public void println(Xxx xx) 特有方法：打印任意类型的数据并且换行 public void print(Xxx xx) 特有方法：打印任意类型的数据，不换行 public void printf(String format, Object... args) 特有方法：带有占位符的打印语句
//1.创建字符打印流的对象
PrintWriter pw = new PrintWriter(new FileWriter("myio\\a.txt"), true);//2.写出数据
pw.println("今天你终于叫我名字了，虽然叫错了，但是没关系，我马上改");
pw.print("你好你好");
pw.printf("%s爱上了%s","阿珍","阿强");//3.释放资源
pw.close();
打印流总结： 打印流有几种？各有什么特点？有字节打印流和字符打印流两种打印流不操作数据源，只能操作目的地字节打印流：默认自动刷新，特有的 println 自动换行字符打印流：自动刷新需要开启，特有的 println 自动换行
32.解压缩流
package a32_解压缩流;import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;public class Test {public static void main(String[] args) throws IOException {
// 解压本质：把每一个ZipEntry按照层级拷贝到本地另一个文件夹中//1.创建一个File表示要解压的压缩包File src = new File("D:\\aaa.zip");//2.创建一个File表示解压的目的地File dest = new File("D:\\");//调用方法unzip(src, dest);}//定义一个方法用来解压public static void unzip(File src, File dest) throws IOException {//解压的本质：把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地当中//创建一个解压缩流用来读取压缩包中的数据ZipInputStream zip = new ZipInputStream(new FileInputStream(src));//要先获取到压缩包里面的每一个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();}
}
33.压缩流
压缩单个文件
package a33_压缩流;import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;public class a01_压缩单个文件 {public static void main(String[] args) throws IOException {
// 压缩本质：把每一个（文件 / 文件夹）看成ZipEntry对象放到压缩包中// 需求:把D:\\a.txt打包成一个压缩包//1.创建File对象表示要压缩的文件File src = new File("D:\\a.txt");//2.创建File对象表示压缩包的位置File dest = new File("D:\\");//3.调用方法用来压缩toZip(src, dest);}/** 作用：压缩* 参数一：表示要压缩的文件* 参数二：表示压缩包的位置*/public static void toZip(File src, File dest) throws IOException {//1.创建压缩流关联压缩包ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest, "a.zip")));//2.创建ZipEntry对象，表示压缩包里面的每一个文件和文件夹ZipEntry entry = new ZipEntry("a.txt");//3.把ZipEntry对象放到压缩包当中zos.putNextEntry(entry);//4.把src文件中的数据写到压缩包当中FileInputStream fis = new FileInputStream(src);int b;while ((b = fis.read()) != -1) {zos.write(b);}zos.closeEntry();zos.close();}
}
压缩文件夹
package a33_压缩流;import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;public class a02_压缩文件夹 {public static void main(String[] args) throws IOException {
// 压缩流
// 需求:把D:\\aaa文件夹压缩成一个压缩包//1.创建File对象表示要压缩的文件夹File src = new File("D:\\aaa");//2.创建File对象表示压缩包放在哪里（压缩包的父级路径）File destParent = src.getParentFile();//D:\\//3.创建File对象表示压缩包的路径File dest = new File(destParent,src.getName() + ".zip");//4.创建压缩流关联压缩包ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));//5.获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中toZip(src,zos,src.getName());//src.getName():aaa//6.释放资源zos.close();}/** 作用：获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中* 参数一：数据源* 参数二：压缩流* 参数三：压缩包内部的路径*/public static void toZip(File src,ZipOutputStream zos,String name) throws IOException {//1.进入src文件夹File[] files = src.listFiles();//2.遍历数组for (File file : files) {if(file.isFile()){//3.判断-文件，变成ZipEntry对象，放入到压缩包当中ZipEntry entry = new ZipEntry(name + "\\" + file.getName());zos.putNextEntry(entry);//读取文件中的数据，写到压缩包FileInputStream fis = new FileInputStream(file);int b;while((b = fis.read()) != -1){zos.write(b);}fis.close();zos.closeEntry(); // 表示当前文件书写完毕}else{//4.判断-文件夹，递归toZip(file,zos, name + "\\" + file.getName());}}}
}
34.常用工具包
使用前需导包！！！
Commons-io
FileUtils类static void copyFile(File srcFile, File destFile) //复制文件static void copyDirectory(File srcDir, File destDir) //复制文件夹static void copyDirectoryToDirectory(File srcDir, File destDir) //复制文件夹static void deleteDirectory(File directory) //删除文件夹static void cleanDirectory(File directory) //清空文件夹static String readFileToString(File file, Charset encoding) //读取文件中的数据变成字符串static void write(File file, CharSequence data, String encoding) //写出数据IOUtils类public static int copy(InputStream input, OutputStream output) //复制文件public static int copyLarge(Reader input, Writer output) //复制大文件public static String readLines(Reader input) //读取数据public static void write(String data, OutputStream output) //写出数据
File src = new File("myio\\a.txt");
File dest = new File("myio\\copy.txt");
FileUtils.copyFile(src,dest);
File src = new File("D:\\aaa");
File dest = new File("D:\\bbb");
FileUtils.copyDirectoryToDirectory(src,dest);
File src = new File("D:\\bbb");
FileUtils.cleanDirectory(src);
hutool
package a34_常用工具包;public class a02_hutool {public static void main(String[] args) {/*FileUtil类:file：根据参数创建一个file对象touch：根据参数创建文件writeLines：把集合中的数据写出到文件中，覆盖模式。appendLines：把集合中的数据写出到文件中，续写模式。readLines：指定字符编码，把文件中的数据，读到集合中。readUtf8Lines：按照UTF-8的形式，把文件中的数据，读到集合中copy：拷贝文件或者文件夹*/// File file = FileUtil.file("D:\\", "aaa", "bbb", "a.txt");
// System.out.println(file);//D:\aaa\bbb\a.txt
//
// File touch = FileUtil.touch(file);
// System.out.println(touch);/*FileUtil类:file：根据参数创建一个file对象touch：根据参数创建文件writeLines：把集合中的数据写出到文件中，覆盖模式。appendLines：把集合中的数据写出到文件中，续写模式。readLines：指定字符编码，把文件中的数据，读到集合中。readUtf8Lines：按照UTF-8的形式，把文件中的数据，读到集合中copy：拷贝文件或者文件夹*/// File file = FileUtil.file("D:\\", "aaa", "bbb", "a.txt");
// System.out.println(file);//D:\aaa\bbb\a.txt
//
// File touch = FileUtil.touch(file);
// System.out.println(touch);
//
// ArrayList<String> list = new ArrayList<>();
// list.add("aaa");
// list.add("aaa");
// list.add("aaa");
//
// File file2 = FileUtil.writeLines(list, "D:\\a.txt", "UTF-8");
// System.out.println(file2);/* ArrayList<String> list = new ArrayList<>();list.add("aaa");list.add("aaa");list.add("aaa");File file3 = FileUtil.appendLines(list, "D:\\a.txt", "UTF-8");System.out.println(file3);*/// List<String> list = FileUtil.readLines("D:\\a.txt", "UTF-8");
// System.out.println(list);}
}
35.综合练习
网络爬虫
package a35_综合练习;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 a01_网络爬虫 {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, "([\\u4E00-\\u9FA5]{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);System.out.println(list);//6.写出数据BufferedWriter bw = new BufferedWriter(new FileWriter("a23_IO流\\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;}/** 作用：根据正则表达式获取字符串中的数据* 参数一：* 完整的字符串* 参数二：* 正则表达式* 参数三：* ？？？* 返回值：* 真正想要的数据*/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();}
}
利用糊涂包生成假数据
package a35_综合练习;import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.http.HttpUtil;import java.util.*;public class a02_利用糊涂包生成假数据 {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("([\\u4E00-\\u9FA5]{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);System.out.println(list);//6.写出数据//细节：//糊涂包的相对路径，不是相对于当前项目而言的，而是相对class文件而言的FileUtil.writeLines(list, "names.txt", "UTF-8");}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;}
}
带权重的随机算法
package a35_综合练习.a03_带权重的随机算法;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("a23_IO流\\src\\a35_综合练习\\a03_带权重的随机算法\\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这个数据在数组当中的插入点位置// 插入点 = - 结果 - 1int 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("a23_IO流\\src\\a35_综合练习\\a03_带权重的随机算法\\names.txt"));for (Student s : list) {bw.write(s.toString());bw.newLine();}bw.close();}
}
登录注册
package a35_综合练习.a04_登录注册;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=123br.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("登陆失败");}}
}
36.配置文件properties的基本使用
配置文件 好处1：可以把软件的设置永久化存储 好处2：如果我们要修改参数，不需要改动代码，直接修改配置文件就可以了properties 是一个双列集合集合，拥有 Map 集合所有的特点。 重点：有一些特有的方法，可以把集合中的数据，按照键值对的形式写到配置文件当中。也可以把配置文件中的数据，读取到集合中来。 Properties 作为双列集合的方法 Properties 中特有的读写方法
基本用法
package a36_配置文件properties的基本使用;import java.util.Map;
import java.util.Properties;
import java.util.Set;public class a01_基本用法 {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);}}
}
跟IO流结合的特有方法
package a36_配置文件properties的基本使用;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;public class a02_跟IO流结合的特有方法 {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.把集合中的数据以键值对的形式写到本地文件当中// 用原来的方法
// 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();// 用特有方法存入FileOutputStream fos = new FileOutputStream("myiotest\\a.properties");prop.store(fos,"test"); // test是注释fos.close();//4.读取本地Properties文件里面的数据//创建集合Properties prop2 = new Properties();//读取FileInputStream fis = new FileInputStream("myiotest\\a.properties");prop2.load(fis);fis.close();System.out.println(prop2);}
}