一文掌握Java IO流：原理、分类与实战
稀
AirMan约 15 分钟
AirMan约 15 分钟I/O 流
IO 流：存储数据和读取数据的解决方案，input / output。「流就是像水一样的传输数据」
IO流按照操作文件的类型可为
字节流：可以操作所有类型的文件 字符流：只能操作纯文本文件
「IO 流的体系图」
「缓冲流体系」：缓冲流就是会增加一个缓冲区，提高文件读写的效率，字符缓冲流提升的不是很明显（因为字符流本身会创建一个8192字节大小的缓冲区）
「IO 流原则」
随用随创建(不要提前创建，可能会覆盖文件) 什么时候不用什么时候关闭
字节流
FileInputStream：操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中来
使用步骤
public FileInputStream(File file, true/false)
public FileInputStream(String pathname， true/false)
如果文件不存在，就直接报错；如果写入参数 true 那么就会在原有文件内继续添加
public int read()
一次读一个字节数据，读出来的是数据在 ASCII 上对应的数字
读取一个数据就移动一次指针，读到文件末尾了，read 方法返回 -1
public int read(byte[] buffer)
一次读取多个字节数据，具体读多少，跟数组的长度有关
返回值：本次读取到了多少个字节数据
使用public String(char value[], int offset, int count)转换为字符串
读取结束的时候，read 方法会方法一个 -1
// 1. 创建输入流对象，指定文件路径FileInputStream fis = new FileInputStream("example.txt");// 2. 逐字节读取文件内容int data;while ((data = fis.read()) != -1) { // read() 返回单个字节，读到末尾时返回 -1System.out.print((char) data); // 强转为 char，输出字符// 3. 关闭流，释放系统资源fis.close();
FileOutputStream：操作本地文件的字节输出流，可以把程序中的数据写到本地文件中，可以把程序中的数据写到本地文件上，是字节流的基本流
使用步骤
public FileOutputStream( File file, true/false)
public FileOutputStream(String pathname, true/false)
如果文件不存在，就直接报错；如果写入参数 true 那么就会在原有文件内继续添加；如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的
public void write(int b)
一次写一个字节数据
write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
void write(byte[] b)
一次写一个字节数组数据
void write(byte[] b, int off, int len)
一次写一个字节数组的部分数据
参数一是字节数组；参数二是起始索引；参数三是个数
字符流
「字符流的底层就是字节流。字符流 = 字节流 + 字符集」
FileReader：操作本地文件的字符输入流，可以把本地文件中的数据读取到程序中来
public FileReader(File file, true/false) public FileReader(String pathname, true/false) 如果文件不存在，就直接报错
public int read()
读取数据，读到末尾返回-1
public int read(char[] buffer)
读取多个数据，读到末尾返回-1 读取数据，解码，强制转换三个步骤合并了，把强转之后的字符放到数组当中 等同于空参的read + 强转类型转换 使用public String(char value[], int offset, int count)转换为字符串
public void close()
释放资源/关流
FIleWriter：操作本地文件的字节输出流，可以把程序中的数据写到本地文件中
public FIleWriter(File file, true/false)
public FIleWriter(String pathname, true/false)
如果文件不存在，就直接报错
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)
写出字符数组的一部分
释放资源/关流
字符流的原理
创建字符输入流对象
底层：关联文件，并创建缓冲区(长度为 8192 的字节数组)
读取数据
判断缓冲区中是否有数据可以读取 缓冲区没有数据:就从文件中获取数据，装到缓冲区中，每次尽可能装满缓冲区，如果文件中也没有数据了，返回-1 缓冲区有数据:就从缓冲区中读取。（空参的read方法:一次读取一个字节，遇到中文一次读多个字节，把字节解码并转成十进制返回，有参的read方法:把读取字节，解码，强转三步合并了，强转之后的字符放到数组中）
字符流输出和字符流输入都有一个 8192 字节的缓冲区，当缓冲区满了就会自动将数据写入目的地 public void flush()
刷新之后，还可以继续往文件中写出数据
public void close()
断开通道，无法再往文件中写出数据
字符集
在计算机中，任意数据都是以二进制的形式来存储的；计算机中最小的存储单元是一个字节；简体中文版 Windows，默认使用 GBK 字符集；GBK 字符集完全兼容 ASCII 字符集
ASCII 字符集中，一个英文占一个字节。一个英文占一个字节，二进制第一位是 0
汉字两个字节存储，二进制高位字节的第一位是 1，转成十进制之后是一个负数
Unicode，UTF（Unicode Transfer Format）。Unicode 字符集的 UTF-8 编码格式
一个英文占一个字节，二进制第一位是 0，转成十进制是正数 一个中文占三个字节，二进制第一位是 1，第一个字节转成十进制是负数
Java 的编码的方法
public byte[] getBytes()使用默认方式进行编码public byte[] getBytes(String charsetName)使用指定方式进行编码
String(byte[] bytes)使用默认方式进行解码String(byte[] bytes, String charsetName)使用指定方式进行解码
缓冲流
「字节缓冲流」
缓冲流提高效率的原理，就是在内存中创建一个缓存区，减少了磁盘的读写次数，中间的遍历只是为了在输入输出缓冲流之间进行“倒手数据”(在内存中这个速度非常快)
创建一个 size 字节大小的字节缓存输入流（把基本流包装为高级流） public BufferedInputStream(InputStream in, int size)创建一个 size 字节大小的字节缓存输出流（把基本流包装为高级流） public BufferedOutputStream(OutputStream out, int size)读写入一个字节的数据 read() // write(int c)读写入多个字节的数据 read(byte[] bytes) // write(bytes, 0, len)
「字符缓冲流」
创建一个size*2字节大小的字符「缓存输入流」(因为 char 类型在 Java 中的大小是两字节) 「BufferedReader」 把基本流包装为高级流public BufferedReader(Reader r)
特有方法，读一整行：public String readLine()
该方法不会将 换行符 读入到缓冲区中 读到结尾的时候，该方法返回 null
创建一个size*2字节大小的字符「缓存输出流」(因为 char 类型在 Java 中的大小是两字节) 「BufferedWriter」 把基本流包装为高级流public BufferedWriter(Writer r)
特有方法，跨平台的换行public void newLine()
会根据不同的操作系统写入一个换行符
转换流
字符转换输入流：InputstreamReader
字符转换输出流：0utputStreamWriter
转化流是字节流和字符流之间的桥梁。「字节流在读取中文的时候，是会出现乱码的，但是字符流可以搞定」
//1.字节流在读取中文的时候，是会出现乱码的，但是字符流可以搞定FileInputStream fis = new FileInputStream("gbk.txt");// 包装字节流为转换流，这就就能按照字节读取且不乱码InputStreamReader isr = new InputStreamReader(fis, Charset.forName("GBK"));//2.字节流里面是没有读一整行的方法的，只有字符缓冲流才能搞定BufferedReader br = new BufferedReader(isr); // 只有 BufferedReader 缓冲流 才能按行读取，所以需要将转换流继续包装为缓冲流String line;while ((line = br.readLine()) != null)System.out.println(line);br.close();
序列化流 / 反序列化流
「序列化流的对象 / 对象操作输出流」
把基本流变成高级流 public ObjectOutputStream (OutputStream out)把对象序列化（写出）到文件中去 public final void writeObject (Object obj)
对象必须要实现 Serializable 接口 （这个接口只是一个标记性接口，里面没有抽象方法，只表示当前的类可以被序列化）， 如果没有实现接口，就会抛出 NotSerializableException 异常
public void close()// 1.创建对象Student stu = new Student("zhangsan",23);// 2.创建序列化流的对象/对象操作输出流ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student_objet.txt"));// 3.写出数据oos.writeObject (stu);// 4.释放资源oos.close();
「反序列化流 / 对象操作输入流」
把基本流变成高级流 public ObjectInputStream(InputStream out)把文件反序列化（读入）到程序中去 public Object readObject()
对象必须要实现 Serializable 接口 （这个接口只是一个标记性接口，里面没有抽象方法，只表示当前的类可以被反序列化）， 如果没有实现接口，就会抛出 deserialization 异常
public void close()// 1.创建反序列化流的对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student_objet.txt"));// 2.读取数据Student stu = (Student)ois.readObject();// 3.打印对象System.out.println(stu);// 4.释放资源ois.close();
注意：
使用序列化流将对象写到文件时，需要让 Javabean 类实现 Serializable 接口。否则，会出现 NotSerializableException 异常 序列化流写到文件中的数据是不能修改的，一旦修改就无法再次读回来了 序列化对象后，修改了Javabean类，再次反序列化，会不会有问题?
会出问题，会抛出InvalidclassException异常 解决方案:给 Javabean 类添加 serialVersionUID (列号、版本号) 方法1：手动写private static final long serialVersionUID = num; 方法2：IDEA中修改 Serializable 方法3：从别的类中直接复制
解决方案：给该成员变量加 transient（瞬态关键字）关键字修饰，该关键字标记的成员变量不参与列化过程
打印流
打印流只能写不能读，即打印流不操作数据源，只能操作目的地
字节打印流
关联字节输出流/文件/文件路径 public PrintStream(OutputStream/File/String)指定字符编码 public PrintStream(String fileName, Charset charset)自动刷新 public PrintStream(OutputStreamout, 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)
package myprintstream;import java.io.FileNotFoundException;import java.io.PrintStream;import java.util.Date;public class Demo2 {public static void main(String[] args) throws FileNotFoundException {PrintStream ps = new PrintStream("day27-code\\src\\myprintstream\\占位符.txt");//% n表示换行ps.printf("我叫%s %n", "阿玮");ps.printf("%s喜欢%s %n", "阿珍", "阿强");ps.printf("字母H的大写：%c %n", 'H');ps.printf("8>3的结果是：%b %n", 8 > 3);ps.printf("100的一半是：%d %n", 100 / 2);ps.printf("100的16进制数是：%x %n", 100);ps.printf("100的8进制数是：%o %n", 100);ps.printf("50元的书打8.5折扣是：%f元%n", 50 * 0.85);ps.printf("计算的结果转16进制：%a %n", 50 * 0.85);ps.printf("计算的结果转科学计数法表示：%e %n", 50 * 0.85);ps.printf("计算的结果转成指数和浮点数，结果的长度较短的是：%g %n", 50 * 0.85);ps.printf("带有百分号的符号表示法，以百分之85为例：%d%% %n", 85);ps.println("---------------------");double num1 = 1.0;ps.printf("num: %.4g %n", num1);ps.printf("num: %.5g %n", num1);ps.printf("num: %.6g %n", num1);float num2 = 1.0F;ps.printf("num: %.4f %n", num2);ps.printf("num: %.5f %n", num2);ps.printf("num: %.6f %n", num2);ps.println("---------------------");ps.printf("数字前面带有0的表示方式：%03d %n", 7);ps.printf("数字前面带有0的表示方式：%04d %n", 7);ps.printf("数字前面带有空格的表示方式：% 8d %n", 7);ps.printf("整数分组的效果是：%,d %n", 9989997);ps.println("---------------------");//最终结果是10位，小数点后面是5位，不够在前面补空格，补满10位//如果实际数字小数点后面过长，但是只规定两位，会四舍五入//如果整数部分过长，超出规定的总长度，会以实际为准ps.printf("一本书的价格是：%2.5f元%n", 49.8);ps.printf("%(f%n", -76.04);//%f，默认小数点后面7位，//<，表示采取跟前面一样的内容ps.printf("%f和%3.2f %n", 86.04, 1.789651);ps.printf("%f和%<3.2f %n", 86.04, 1.789651);ps.println("---------------------");Date date = new Date();// %t 表示时间，但是不能单独出现，要指定时间的格式// %tc 周二 12月 06 22:08:40 CST 2022// %tD 斜线隔开// %tF 冒号隔开（12小时制）// %tr 冒号隔开（24小时制）// %tT 冒号隔开（24小时制，带时分秒）ps.printf("全部日期和时间信息：%tc %n", date);ps.printf("月/日/年格式：%tD %n", date);ps.printf("年-月-日格式：%tF %n", date);ps.printf("HH:MM:SS PM格式(12时制)：%tr %n", date);ps.printf("HH:MM格式(24时制)：%tR %n", date);ps.printf("HH:MM:SS格式(24时制)：%tT %n", date);System.out.println("---------------------");ps.printf("星期的简称：%ta %n", date);ps.printf("星期的全称：%tA %n", date);ps.printf("英文月份简称：%tb %n", date);ps.printf("英文月份全称：%tB %n", date);ps.printf("年的前两位数字(不足两位前面补0)：%tC %n", date);ps.printf("年的后两位数字(不足两位前面补0)：%ty %n", date);ps.printf("一年中的第几天：%tj %n", date);ps.printf("两位数字的月份(不足两位前面补0)：%tm %n", date);ps.printf("两位数字的日(不足两位前面补0)：%td %n", date);ps.printf("月份的日(前面不补0)：%te %n", date);System.out.println("---------------------");ps.printf("两位数字24时制的小时(不足2位前面补0):%tH %n", date);ps.printf("两位数字12时制的小时(不足2位前面补0):%tI %n", date);ps.printf("两位数字24时制的小时(前面不补0):%tk %n", date);ps.printf("两位数字12时制的小时(前面不补0):%tl %n", date);ps.printf("两位数字的分钟(不足2位前面补0):%tM %n", date);ps.printf("两位数字的秒(不足2位前面补0):%tS %n", date);ps.printf("三位数字的毫秒(不足3位前面补0):%tL %n", date);ps.printf("九位数字的毫秒数(不足9位前面补0):%tN %n", date);ps.printf("小写字母的上午或下午标记(英)：%tp %n", date);ps.printf("小写字母的上午或下午标记(中)：%tp %n", date);ps.printf("相对于GMT的偏移量:%tz %n", date);ps.printf("时区缩写字符串:%tZ%n", date);ps.printf("1970-1-1 00:00:00 到现在所经过的秒数：%ts %n", date);ps.printf("1970-1-1 00:00:00 到现在所经过的毫秒数：%tQ %n", date);ps.close();}}
字符打印流：「字符流底层有缓冲区，想要自动刷新需要开启」
关联字节输出流/文件/文件路径 public PrintWriter(Write/File/String)指定字符编码 public PrintWriter(String fileName, Charset charset)自动刷新 public PrintWriter(Write, boolean autoFlush)指定字符编码且自动刷新 public PrintWriter(Write 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)
打印流的一个应用
获取打印流的对象，此打印流在虚拟机启动的时候，由虚拟机创建，默认指向控制台 特殊的打印流，系统中的标准输出流。是不能关闭，在系统中是唯一的
PrintStream ps = System.out;ps.println("123");ps.close();ps.println("你好你好");System.out.println("456");
压缩流
解压缩流：解压的本质就是把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地当中
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();}
压缩流（单个文件），创建一个 zip 文件，利用 ZipEntry 对象将文件写入到 zip 文件中
public static void myZip(File src, File dest) throws IOException {// 1.创建一个 zip 文件ZipOutputStream zipos = new ZipOutputStream(new FileOutputStream(new File(dest, "a.zip")));// 2.创建文件或文件夹的 entry 对象，表示压缩包中的文件和文件夹// 参数：压缩包里面的路径 （这个参数很重要）ZipEntry entry = new ZipEntry("a.txt");// 3.将 entry 对象写入到压缩包中zipos.putNextEntry(entry);// 读取需要压缩文件中的内容，写入到entry中去FileInputStream fos = new FileInputStream(src);// 4.像entry中写入内容int b;while ( (b=fos.read()) != -1 )zipos.write(b);// 关闭 entry 对象，表示一个文件处理完毕zipos.closeEntry();zipos.close();}
压缩流（文件夹），利用源文件的父级路径创建目标路径，然后利用压缩流关联压缩包，利用 ZipEntry 对象向压缩包中写入数据。利用递归处理文件夹
/** 压缩流* 需求：* 把D:\\aaa文件夹压缩成一个压缩包* *///1.创建File对象表示要压缩的文件夹File src = new File("day27-code\\src\\myzipstream\\aaa");//2.创建File对象表示压缩包放在哪里（压缩包的父级路径）File destParent = src.getParentFile();//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());//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());//aaa\\no1\\a.txtzos.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());// no1 aaa \\ no1}}}
AI编程资讯AI Coding专区指南：
https://aicoding.juejin.cn/aicoding