JAVA IO流：从基础原理到实战应用

JAVA IO流：从基础原理到实战应用

1.1 本章学习目标与重点

💡 掌握IO流的核心概念与分类，理解字节流与字符流的区别和适用场景。
💡 熟练使用字节流完成文件的读取与写入操作，解决文件拷贝等实际问题。
💡 掌握字符流的使用方法，处理文本文件的编码与解码问题。
💡 了解缓冲流、转换流、对象流等高级IO流的原理，提升IO操作效率。
⚠️ 本章重点是 字节流与字符流的核心用法 和 高级IO流的实战应用，这是JAVA文件操作的必备技能。

1.2 IO流核心概念与分类

1.2.1 什么是IO流

💡 IO流（Input/Output Stream）是JAVA中用于处理设备之间数据传输的技术，主要负责数据的读取（Input）和写入（Output）。
常见的IO操作包括文件读写、网络通信数据传输等。IO流的核心思想是以流的方式处理数据，数据像水流一样从一个设备流向另一个设备，实现数据的传输与处理。

1.2.2 IO流的分类标准

JAVA中的IO流体系庞大，可按照不同标准进行分类，核心分类方式有以下三种：

1. 按数据流向分类

• 输入流：数据从外部设备流向程序，用于读取数据，核心抽象类为 InputStream、Reader。
• 输出流：数据从程序流向外部设备，用于写入数据，核心抽象类为 OutputStream、Writer。

2. 按数据类型分类

• 字节流：以字节（1字节=8位）为单位处理数据，可处理任意类型的文件，如文本、图片、视频等，核心抽象类为 InputStream、OutputStream。
• 字符流：以字符（2字节）为单位处理数据，仅适用于处理文本文件，可直接处理字符编码问题，核心抽象类为 Reader、Writer。

3. 按功能分类

• 节点流：直接与数据源相连，读写数据的基础流，如 FileInputStream、FileReader。
• 处理流：包裹在节点流之上，增强节点流的功能，如缓冲流、转换流、对象流等。

1.2.3 IO流的核心体系图

IO流体系 ├── 字节流 │ ├── 输入字节流：InputStream │ │ ├── FileInputStream（文件字节输入流） │ │ ├── BufferedInputStream（缓冲字节输入流） │ │ └── ObjectInputStream（对象字节输入流） │ └── 输出字节流：OutputStream │ ├── FileOutputStream（文件字节输出流） │ ├── BufferedOutputStream（缓冲字节输出流） │ └── ObjectOutputStream（对象字节输出流） └── 字符流 ├── 输入字符流：Reader │ ├── FileReader（文件字符输入流） │ ├── BufferedReader（缓冲字符输入流） │ └── InputStreamReader（转换输入流） └── 输出字符流：Writer ├── FileWriter（文件字符输出流） ├── BufferedWriter（缓冲字符输出流） └── OutputStreamWriter（转换输出流） 

✅ 核心结论：字节流可处理所有类型文件，是IO流的基础；字符流专门处理文本文件，避免编码问题；处理流需依赖节点流使用，提升IO操作效率。

1.3 字节流的核心用法

1.3.1 字节输入流（FileInputStream）

💡 FileInputStream 是最常用的字节输入流，用于从文件中读取字节数据，适用于所有类型的文件。

基本使用步骤

① 📝 创建 FileInputStream 对象，绑定数据源文件路径。
② 📝 调用 read() 方法读取文件数据。
③ 📝 关闭流资源，释放系统占用。

代码实操1：单字节读取文件

importjava.io.FileInputStream;importjava.io.IOException;/** * FileInputStream单字节读取文件 */publicclassFileInputStreamDemo1{publicstaticvoidmain(String[] args){FileInputStream fis =null;try{// 1. 创建字节输入流对象，绑定数据源 fis =newFileInputStream("test.txt");// 2. 读取数据：read()方法每次读取一个字节，返回读取的字节值，读到末尾返回-1int readByte;while((readByte = fis.read())!=-1){// 字节转字符输出（适用于文本文件）System.out.print((char) readByte);}}catch(IOException e){ e.printStackTrace();}finally{// 3. 关闭流资源if(fis !=null){try{ fis.close();}catch(IOException e){ e.printStackTrace();}}}}}

⚠️ 注意事项：单字节读取效率极低，因为每次都要访问磁盘，适合小文件读取，大文件不推荐使用。

代码实操2：字节数组读取文件

importjava.io.FileInputStream;importjava.io.IOException;/** * FileInputStream字节数组读取文件（高效读取） */publicclassFileInputStreamDemo2{publicstaticvoidmain(String[] args){FileInputStream fis =null;try{ fis =newFileInputStream("test.txt");// 定义字节数组缓冲区，大小一般为1024的倍数byte[] buffer =newbyte[1024];// read(byte[] b)：读取字节到数组中，返回读取的有效字节数，末尾返回-1int len;while((len = fis.read(buffer))!=-1){// 将字节数组转换为字符串，注意取有效长度lenSystem.out.print(newString(buffer,0, len));}}catch(IOException e){ e.printStackTrace();}finally{if(fis !=null){try{ fis.close();}catch(IOException e){ e.printStackTrace();}}}}}

✅ 核心结论：字节数组读取是推荐的高效读取方式，通过缓冲区减少磁盘IO次数，大幅提升读取效率。

1.3.2 字节输出流（FileOutputStream）

💡 FileOutputStream 是最常用的字节输出流，用于向文件中写入字节数据，支持覆盖写入和追加写入两种模式。

基本使用步骤

① 📝 创建 FileOutputStream 对象，绑定目标文件路径。
② 📝 调用 write() 方法写入数据。
③ 📝 关闭流资源。

代码实操1：覆盖写入文件

importjava.io.FileOutputStream;importjava.io.IOException;/** * FileOutputStream覆盖写入文件 */publicclassFileOutputStreamDemo1{publicstaticvoidmain(String[] args){FileOutputStream fos =null;try{// 1. 创建字节输出流对象，默认覆盖写入模式 fos =newFileOutputStream("output.txt");// 2. 写入数据// 方式1：写入单个字节 fos.write(97);// 写入字符'a'的ASCII码// 方式2：写入字节数组byte[] bytes ="Hello FileOutputStream".getBytes(); fos.write(bytes);// 方式3：写入字节数组的指定部分byte[] partBytes ="Java IO Stream".getBytes(); fos.write(partBytes,0,4);// 只写入前4个字节"Java"System.out.println("文件写入成功！");}catch(IOException e){ e.printStackTrace();}finally{// 3. 关闭流资源if(fos !=null){try{ fos.close();}catch(IOException e){ e.printStackTrace();}}}}}

代码实操2：追加写入文件

importjava.io.FileOutputStream;importjava.io.IOException;/** * FileOutputStream追加写入文件 */publicclassFileOutputStreamDemo2{publicstaticvoidmain(String[] args){FileOutputStream fos =null;try{// 构造方法第二个参数为true时，开启追加写入模式 fos =newFileOutputStream("output.txt",true);// 写入换行符（不同系统换行符不同：Windows->\r\n，Linux->\n） fos.write("\r\n".getBytes());// 追加写入新内容 fos.write("这是追加的内容".getBytes());System.out.println("内容追加成功！");}catch(IOException e){ e.printStackTrace();}finally{if(fos !=null){try{ fos.close();}catch(IOException e){ e.printStackTrace();}}}}}

⚠️ 注意事项：写入文件时，如果目标文件不存在，FileOutputStream 会自动创建文件；如果父目录不存在，则会抛出 FileNotFoundException。

1.3.3 实战：字节流实现文件拷贝

💡 文件拷贝是IO流的典型应用场景，通过字节输入流读取源文件数据，再通过字节输出流写入目标文件，可实现任意类型文件的拷贝。

代码实现

importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;/** * 字节流实现文件拷贝（支持所有类型文件：文本、图片、视频等） */publicclassFileCopyDemo{publicstaticvoidmain(String[] args){// 源文件路径和目标文件路径String sourcePath ="source.jpg";String targetPath ="target_copy.jpg";FileInputStream fis =null;FileOutputStream fos =null;try{// 1. 创建字节输入流和输出流 fis =newFileInputStream(sourcePath); fos =newFileOutputStream(targetPath);// 2. 定义缓冲区，提升拷贝效率byte[] buffer =newbyte[1024*8];// 8KB缓冲区int len;// 3. 循环读取并写入数据long startTime =System.currentTimeMillis();while((len = fis.read(buffer))!=-1){ fos.write(buffer,0, len);}long endTime =System.currentTimeMillis();System.out.println("文件拷贝成功！耗时："+(endTime - startTime)+"ms");}catch(IOException e){ e.printStackTrace();}finally{// 4. 关闭流资源，先关输出流，再关输入流try{if(fos !=null) fos.close();if(fis !=null) fis.close();}catch(IOException e){ e.printStackTrace();}}}}

✅ 核心结论：字节流拷贝文件的核心是边读边写，通过合理设置缓冲区大小（如8KB、16KB），可以大幅提升拷贝效率，这是文件拷贝的标准实现方式。

1.4 字符流的核心用法

1.4.1 字符流的设计初衷

💡 字节流处理文本文件时，需要手动处理字符编码问题，容易出现乱码。字符流以字符为单位处理数据，内部集成了编码解码逻辑，专门用于处理文本文件，避免乱码问题。
字符流与字节流的核心区别：字节流处理字节，字符流处理字符；字符流底层还是基于字节流实现，只是多了编码解码的步骤。

1.4.2 字符输入流（FileReader）

基本使用步骤

① 📝 创建 FileReader 对象，绑定数据源文本文件。
② 📝 调用 read() 方法读取字符数据。
③ 📝 关闭流资源。

代码实操：字符数组读取文本文件

importjava.io.FileReader;importjava.io.IOException;/** * FileReader读取文本文件 */publicclassFileReaderDemo{publicstaticvoidmain(String[] args){FileReader fr =null;try{// 1. 创建字符输入流对象，默认使用系统编码 fr =newFileReader("test.txt");// 2. 字符数组读取数据char[] buffer =newchar[1024];int len;while((len = fr.read(buffer))!=-1){// 直接转换为字符串输出，无需手动处理编码System.out.print(newString(buffer,0, len));}}catch(IOException e){ e.printStackTrace();}finally{// 3. 关闭流资源if(fr !=null){try{ fr.close();}catch(IOException e){ e.printStackTrace();}}}}}

1.4.3 字符输出流（FileWriter）

基本使用步骤

① 📝 创建 FileWriter 对象，绑定目标文本文件。
② 📝 调用 write() 方法写入字符数据。
③ 📝 调用 flush() 方法刷新缓冲区（可选），关闭流资源。

代码实操：字符流写入文本文件

importjava.io.FileWriter;importjava.io.IOException;/** * FileWriter写入文本文件 */publicclassFileWriterDemo{publicstaticvoidmain(String[] args){FileWriter fw =null;try{// 1. 创建字符输出流对象，开启追加写入模式 fw =newFileWriter("text_output.txt",true);// 2. 写入数据// 方式1：写入单个字符 fw.write('J');// 方式2：写入字符数组char[] chars ={'a','v','a'}; fw.write(chars);// 方式3：写入字符串（最常用） fw.write(" 字符流写入测试\r\n");// 刷新缓冲区：将缓冲区数据写入文件，流可以继续使用 fw.flush(); fw.write("刷新后继续写入的内容");System.out.println("文本写入成功！");}catch(IOException e){ e.printStackTrace();}finally{// 3. 关闭流资源：close()方法会自动调用flush()if(fw !=null){try{ fw.close();}catch(IOException e){ e.printStackTrace();}}}}}

⚠️ 注意事项：字符流的 flush() 方法用于将缓冲区数据写入文件，close() 方法会自动调用 flush()；字节流没有缓冲区，无需调用 flush()。

1.5 高级IO流的实战应用

1.5.1 缓冲流：提升IO操作效率

💡 缓冲流（BufferedInputStream/BufferedOutputStream、BufferedReader/BufferedWriter）是处理流的一种，通过在内存中创建缓冲区，减少磁盘IO次数，大幅提升读写效率。
缓冲流的核心原理：读取数据时，先将数据读取到缓冲区，后续读取直接从缓冲区获取；写入数据时，先写入缓冲区，缓冲区满或关闭流时再写入磁盘。

代码实操1：缓冲字节流实现高效文件拷贝

importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;/** * 缓冲字节流实现高效文件拷贝 */publicclassBufferedFileCopyDemo{publicstaticvoidmain(String[] args){String sourcePath ="large_file.zip";String targetPath ="large_file_copy.zip";BufferedInputStream bis =null;BufferedOutputStream bos =null;try{// 1. 缓冲流包裹节点流 bis =newBufferedInputStream(newFileInputStream(sourcePath)); bos =newBufferedOutputStream(newFileOutputStream(targetPath));// 2. 读取写入数据byte[] buffer =newbyte[1024*8];int len;long startTime =System.currentTimeMillis();while((len = bis.read(buffer))!=-1){ bos.write(buffer,0, len);}long endTime =System.currentTimeMillis();System.out.println("大文件拷贝成功！耗时："+(endTime - startTime)+"ms");}catch(IOException e){ e.printStackTrace();}finally{// 3. 关闭流：关闭缓冲流会自动关闭底层的节点流try{if(bos !=null) bos.close();if(bis !=null) bis.close();}catch(IOException e){ e.printStackTrace();}}}}

代码实操2：缓冲字符流读取文本文件（按行读取）

importjava.io.BufferedReader;importjava.io.FileReader;importjava.io.IOException;/** * BufferedReader按行读取文本文件（最常用的文本读取方式） */publicclassBufferedReaderDemo{publicstaticvoidmain(String[] args){BufferedReader br =null;try{// 1. 创建缓冲字符输入流 br =newBufferedReader(newFileReader("test.txt"));// 2. 按行读取数据：readLine()方法返回一行字符串，末尾返回nullString line;while((line = br.readLine())!=null){System.out.println(line);}}catch(IOException e){ e.printStackTrace();}finally{// 3. 关闭流if(br !=null){try{ br.close();}catch(IOException e){ e.printStackTrace();}}}}}

✅ 核心结论：缓冲流是提升IO效率的首选方式，处理大文件时优势明显；BufferedReader 的 readLine() 方法是读取文本文件的标准方式。

1.5.2 转换流：处理字符编码问题

💡 转换流（InputStreamReader/OutputStreamWriter）是字节流与字符流之间的桥梁，用于指定字符编码读取或写入文本文件，解决乱码问题。
当系统默认编码与文件编码不一致时，必须使用转换流指定编码，否则会出现乱码。

代码实操：指定编码读取文本文件

importjava.io.FileInputStream;importjava.io.IOException;importjava.io.InputStreamReader;/** * InputStreamReader指定编码读取文本文件 */publicclassInputStreamReaderDemo{publicstaticvoidmain(String[] args){InputStreamReader isr =null;try{// 1. 创建转换流，指定编码为UTF-8FileInputStream fis =newFileInputStream("utf8_file.txt"); isr =newInputStreamReader(fis,"UTF-8");// 2. 读取数据char[] buffer =newchar[1024];int len;while((len = isr.read(buffer))!=-1){System.out.print(newString(buffer,0, len));}}catch(IOException e){ e.printStackTrace();}finally{if(isr !=null){try{ isr.close();}catch(IOException e){ e.printStackTrace();}}}}}

⚠️ 注意事项：转换流的编码参数必须与文件实际编码一致，常见的编码格式有 UTF-8、GBK、GB2312 等。

1.5.3 对象流：实现对象的序列化与反序列化

💡 对象流（ObjectInputStream/ObjectOutputStream）用于将JAVA对象转换为字节序列（序列化），或将字节序列恢复为JAVA对象（反序列化），实现对象的持久化存储或网络传输。

序列化的前提条件

1. 目标对象的类必须实现 Serializable 标记接口（该接口没有任何方法，仅用于标记）。
2. 类中的所有属性必须是可序列化的（基本数据类型默认可序列化，引用类型需实现 Serializable）。
3. 可通过 transient 关键字修饰属性，使其不参与序列化。

代码实操1：对象序列化

importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.ObjectOutputStream;importjava.io.Serializable;/** * 对象序列化：将User对象写入文件 */// 实现Serializable接口，标记该类可序列化classUserimplementsSerializable{// 序列化版本号：用于保证序列化和反序列化的类版本一致privatestaticfinallong serialVersionUID =1L;privateString username;privateint age;// transient修饰的属性不参与序列化privatetransientString password;publicUser(String username,int age,String password){this.username = username;this.age = age;this.password = password;}@OverridepublicStringtoString(){return"User{"+"username='"+ username +'\''+", age="+ age +",+ password +'\''+'}';}}publicclassObjectOutputStreamDemo{publicstaticvoidmain(String[] args){ObjectOutputStream oos =null;try{// 1. 创建对象输出流 oos =newObjectOutputStream(newFileOutputStream("user.obj"));// 2. 序列化对象User user =newUser("zhangsan",20,"123456"); oos.writeObject(user);System.out.println("对象序列化成功！");}catch(IOException e){ e.printStackTrace();}finally{if(oos !=null){try{ oos.close();}catch(IOException e){ e.printStackTrace();}}}}}

代码实操2：对象反序列化

importjava.io.FileInputStream;importjava.io.IOException;importjava.io.ObjectInputStream;/** * 对象反序列化：从文件中恢复User对象 */publicclassObjectInputStreamDemo{publicstaticvoidmain(String[] args){ObjectInputStream ois =null;try{// 1. 创建对象输入流 ois =newObjectInputStream(newFileInputStream("user.obj"));// 2. 反序列化对象User user =(User) ois.readObject();System.out.println("反序列化得到的对象："+ user);// 注意：transient修饰的password属性值为null}catch(IOException|ClassNotFoundException e){ e.printStackTrace();}finally{if(ois !=null){try{ ois.close();}catch(IOException e){ e.printStackTrace();}}}}}

输出结果

反序列化得到的对象：User{username='zhangsan', age=20, password='null'} 

✅ 核心结论：对象流是实现对象持久化的核心技术，serialVersionUID 用于保证类版本一致，transient 关键字可排除不需要序列化的属性。

1.6 IO流的最佳实践与常见问题

1.6.1 IO流的最佳实践

1. 优先使用缓冲流：缓冲流能大幅提升IO效率，处理大文件时必须使用。
2. 合理设置缓冲区大小：缓冲区大小建议设置为1024的倍数，如8KB、16KB，过大或过小都会影响效率。
3. 及时关闭流资源：流资源使用完毕后必须关闭，释放系统资源，推荐使用 try-with-resources 语法自动关闭流。
4. 处理文本文件优先使用字符流：字符流自动处理编码问题，避免乱码；处理非文本文件必须使用字节流。
5. 指定编码格式：读取文本文件时，尽量指定编码格式，避免依赖系统默认编码导致乱码。

1.6.2 常见问题与解决方案

❌ 问题1：文件找不到异常（FileNotFoundException）

• 原因：文件路径错误、父目录不存在、文件权限不足。
• 解决方案：检查文件路径是否正确；创建父目录；确保程序有文件访问权限。

❌ 问题2：文本文件读取乱码

• 原因：编码格式不匹配。
• 解决方案：使用转换流 InputStreamReader 指定正确的编码格式。

❌ 问题3：对象反序列化失败（InvalidClassException）

• 原因：序列化和反序列化的类版本不一致、类未实现 Serializable 接口。
• 解决方案：添加 serialVersionUID；确保类实现 Serializable 接口。

❌ 问题4：流关闭顺序错误

• 原因：先关闭节点流，再关闭处理流，导致处理流关闭时出错。
• 解决方案：关闭流时先关闭处理流，再关闭节点流；或直接关闭处理流，底层节点流会自动关闭。

1.6.3 try-with-resources语法自动关闭流

💡 JDK 7 引入的 try-with-resources 语法，可自动关闭实现了 AutoCloseable 接口的资源，无需手动关闭流，代码更简洁，且能避免资源泄漏。

代码实操

importjava.io.BufferedReader;importjava.io.FileReader;importjava.io.IOException;/** * try-with-resources自动关闭流 */publicclassTryWithResourcesDemo{publicstaticvoidmain(String[] args){// 流对象定义在try的括号中，代码执行完毕后自动关闭try(BufferedReader br =newBufferedReader(newFileReader("test.txt"))){String line;while((line = br.readLine())!=null){System.out.println(line);}}catch(IOException e){ e.printStackTrace();}// 无需手动关闭流，JVM自动处理}}

✅ 核心结论：try-with-resources 是推荐的流资源管理方式，能有效避免因忘记关闭流导致的资源泄漏问题。

1.7 实战案例：文件内容搜索工具

1.7.1 需求分析

💡 实现一个文件内容搜索工具，支持在指定目录下的所有文本文件中搜索指定关键词，并输出包含关键词的文件路径和行内容。
需求如下：

1. 支持指定搜索目录和关键词。
2. 递归遍历目录下的所有文本文件（.txt、.java、.xml 等）。
3. 输出包含关键词的文件路径、行号和行内容。
4. 处理IO异常，保证程序健壮性。

1.7.2 代码实现

importjava.io.BufferedReader;importjava.io.File;importjava.io.FileReader;importjava.io.IOException;/** * 文件内容搜索工具 */publicclassFileContentSearcher{// 支持的文本文件后缀privatestaticfinalString[]SUPPORT_EXTENSIONS={".txt",".java",".xml",".properties"};/** * 递归搜索目录下的文件 * @param dir 搜索目录 * @param keyword 搜索关键词 */publicstaticvoidsearch(File dir,String keyword){// 检查目录是否存在if(!dir.exists()||!dir.isDirectory()){System.out.println("目录不存在或不是有效目录！");return;}// 获取目录下的所有文件和子目录File[] files = dir.listFiles();if(files ==null){return;}for(File file : files){if(file.isDirectory()){// 递归搜索子目录search(file, keyword);}else{// 判断是否为支持的文本文件if(isTextFile(file.getName())){// 搜索文件内容searchFileContent(file, keyword);}}}}/** * 判断是否为支持的文本文件 * @param fileName 文件名 * @return 是文本文件返回true，否则返回false */privatestaticbooleanisTextFile(String fileName){for(String ext :SUPPORT_EXTENSIONS){if(fileName.endsWith(ext)){returntrue;}}returnfalse;}/** * 搜索单个文件的内容 * @param file 目标文件 * @param keyword 搜索关键词 */privatestaticvoidsearchFileContent(File file,String keyword){try(BufferedReader br =newBufferedReader(newFileReader(file))){String line;int lineNum =0;while((line = br.readLine())!=null){ lineNum++;// 判断行内容是否包含关键词if(line.contains(keyword)){System.out.println("====================================");System.out.println("文件路径："+ file.getAbsolutePath());System.out.println("行号："+ lineNum);System.out.println("内容："+ line);}}}catch(IOException e){System.out.println("读取文件失败："+ file.getAbsolutePath()); e.printStackTrace();}}publicstaticvoidmain(String[] args){// 搜索目录和关键词String dirPath ="src";String keyword ="IO流";File dir =newFile(dirPath);System.out.println("开始搜索关键词【"+ keyword +"】...");search(dir, keyword);System.out.println("\n搜索完成！");}}

1.7.3 案例总结

✅ 这个文件内容搜索工具综合运用了IO流的核心知识，核心亮点如下：

1. 使用 BufferedReader 按行读取文本文件，保证读取效率。
2. 递归遍历目录，实现多级目录下的文件搜索。
3. 使用 try-with-resources 自动关闭流，避免资源泄漏。
4. 处理了各种异常情况，保证程序的健壮性。
5. 可灵活扩展支持的文本文件类型，实用性强。

1.8 本章总结

1. IO流是JAVA处理数据传输的核心技术，分为字节流和字符流，字节流处理所有类型文件，字符流专门处理文本文件。
2. 字节流的核心用法是文件读写和拷贝，通过字节数组读取可提升效率；字符流可避免编码问题，readLine() 是读取文本的标准方式。
3. 缓冲流通过缓冲区减少磁盘IO次数，大幅提升IO效率；转换流用于处理编码问题；对象流实现对象的序列化与反序列化。
4. IO流的最佳实践是优先使用缓冲流、及时关闭流资源、指定编码格式、使用 try-with-resources 管理资源。
5. 实际开发中，需根据文件类型选择合适的IO流，处理异常情况，保证程序的健壮性。