Java IO 流是处理输入输出的核心机制，分为字节流和字符流。字节流以字节为单位处理二进制文件，字符流以字符为单位处理文本文件。本文介绍了 FileInputStream、FileOutputStream、FileReader、FileWriter 等基础流的使用，以及缓冲流提升效率的方法。此外还涵盖转换流解决编码问题，对象流实现序列化与反序列化，以及 File 类进行文件目录操作。掌握这些内容是 Java 开发的基础。
：理解 IO 流的基本概念，掌握字节流和字符流的使用方法，了解缓冲流、转换流、对象流等高级流的应用场景，掌握文件操作的方法。
重点：字节流（FileInputStream、FileOutputStream）、字符流（FileReader、FileWriter）、缓冲流（BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter）。
IO 流：用于处理输入和输出操作的流，分为字节流和字符流。
IO 流的分类：
字节流分为输入字节流和输出字节流。
输入字节流的基类是 InputStream，常用的实现类包括 FileInputStream、ByteArrayInputStream 等。
定义：FileInputStream 是用于读取文件内容的输入字节流。
创建对象：
FileInputStream fis = new FileInputStream("文件路径");
示例：
import java.io.FileInputStream;
import java.io.IOException;
public class TestFileInputStream {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("test.txt")) {
int data;
while ((data = fis.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：如果 test.txt 文件的内容是'Hello, Java!'，则输出'Hello, Java!'。
输出字节流的基类是 OutputStream，常用的实现类包括 FileOutputStream、ByteArrayOutputStream 等。
定义：FileOutputStream 是用于写入文件内容的输出字节流。
创建对象：
FileOutputStream fos = new FileOutputStream("文件路径");
示例：
import java.io.FileOutputStream;
import java.io.IOException;
public class TestFileOutputStream {
public static void main(String[] args) {
try (FileOutputStream fos = new FileOutputStream("test.txt")) {
String str = "Hello, Java!";
fos.write(str.getBytes());
System.out.println("文件写入成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：输出'文件写入成功！'，并在 test.txt 文件中写入'Hello, Java!'。
字符流分为输入字符流和输出字符流。
输入字符流的基类是 Reader，常用的实现类包括 FileReader、CharArrayReader 等。
定义：FileReader 是用于读取文本文件内容的输入字符流。
创建对象：
FileReader fr = new FileReader("文件路径");
示例：
import java.io.FileReader;
import java.io.IOException;
public class TestFileReader {
public static void main(String[] args) {
try (FileReader fr = new FileReader("test.txt")) {
int data;
while ((data = fr.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：如果 test.txt 文件的内容是'Hello, Java!'，则输出'Hello, Java!'。
输出字符流的基类是 Writer，常用的实现类包括 FileWriter、CharArrayWriter 等。
定义：FileWriter 是用于写入文本文件内容的输出字符流。
创建对象：
FileWriter fw = new FileWriter("文件路径");
示例：
import java.io.FileWriter;
import java.io.IOException;
public class TestFileWriter {
public static void main(String[] args) {
try (FileWriter fw = new FileWriter("test.txt")) {
String str = "Hello, Java!";
fw.write(str);
System.out.println("文件写入成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：输出'文件写入成功！'，并在 test.txt 文件中写入'Hello, Java!'。
处理流是对节点流进行包装的流，用于提高输入和输出效率。
缓冲流分为缓冲字节流和缓冲字符流，用于提高输入和输出效率。
定义：缓冲字节流是对字节流进行包装的流，包括 BufferedInputStream 和 BufferedOutputStream。
创建对象：
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("文件路径"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("文件路径"));
示例：
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestBufferedStream {
public static void main(String[] args) {
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test_copy.txt"))) {
int data;
while ((data = bis.read()) != -1) {
bos.write(data);
}
System.out.println("文件复制成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：输出'文件复制成功！'，并在 test_copy.txt 文件中写入内容。
✅ 结论：缓冲流可以提高输入和输出效率，建议在实际开发中使用缓冲流。
定义：缓冲字符流是对字符流进行包装的流，包括 BufferedReader 和 BufferedWriter。
创建对象：
BufferedReader br = new BufferedReader(new FileReader("文件路径"));
BufferedWriter bw = new BufferedWriter(new FileWriter("文件路径"));
示例：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class TestBufferedReaderWriter {
public static void main(String[] args) {
try (BufferedReader br = new BufferedReader(new FileReader("test.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("test_copy.txt"))) {
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
System.out.println("文件复制成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：输出'文件复制成功！'，并在 test_copy.txt 文件中写入内容。
转换流分为 InputStreamReader 和 OutputStreamWriter，用于在字节流和字符流之间进行转换。
定义：InputStreamReader 是用于将字节流转换为字符流的流。
创建对象：
InputStreamReader isr = new InputStreamReader(new FileInputStream("文件路径"), "字符编码");
示例：
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class TestInputStreamReader {
public static void main(String[] args) {
try (InputStreamReader isr = new InputStreamReader(new FileInputStream("test.txt"), "UTF-8")) {
int data;
while ((data = isr.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：如果 test.txt 文件的内容是'Hello, Java!'，则输出'Hello, Java!'。
定义：OutputStreamWriter 是用于将字符流转换为字节流的流。
创建对象：
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("文件路径"), "字符编码");
示例：
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class TestOutputStreamWriter {
public static void main(String[] args) {
try (OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test.txt"), "UTF-8")) {
String str = "Hello, Java!";
osw.write(str);
System.out.println("文件写入成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：输出'文件写入成功！'，并在 test.txt 文件中写入'Hello, Java!'。
对象流分为 ObjectInputStream 和 ObjectOutputStream，用于将对象序列化和反序列化。
定义：序列化是将对象转换为字节流的过程。
示例：
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}
public class TestObjectOutputStream {
public static void main(String[] args) {
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))) {
Person person = new Person("张三", 20);
oos.writeObject(person);
System.out.println("对象序列化成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出结果：输出'对象序列化成功！'，并在 person.txt 文件中写入序列化后的对象。
定义：反序列化是将字节流转换为对象的过程。
示例：
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
class Person implements Serializable {
// ... same as above
}
public class TestObjectInputStream {
public static void main(String[] args) {
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"))) {
Person person = (Person) ois.readObject();
System.out.println("对象反序列化成功！");
System.out.println(person);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
输出结果：输出'对象反序列化成功！'和'Person{name='张三', age=20}'。
⚠️ 注意：要使对象可序列化，类必须实现 Serializable 接口。
Java 提供了 File 类，用于操作文件和目录。
示例：
import java.io.File;
import java.io.IOException;
public class TestFile {
public static void main(String[] args) {
// 创建文件对象
File file = new File("test.txt");
// 判断文件是否存在
if (file.exists()) {
System.out.println("文件已存在！");
} else {
System.out.println("文件不存在！");
try {
file.createNewFile();
System.out.println("文件创建成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
// 判断是否是文件
System.out.println("是否是文件：" + file.isFile());
// 判断是否是目录
System.out.println("是否是目录：" + file.isDirectory());
// 获取文件的名称
System.out.println("文件的名称：" + file.getName());
// 获取文件的路径
System.out.println("文件的路径：" + file.getPath());
// 获取文件的绝对路径
System.out.println("文件的绝对路径：" + file.getAbsolutePath());
// 获取文件的大小
System.out.println("文件的大小：" + file.length() + "字节");
// 删除文件
if (file.delete()) {
System.out.println("文件删除成功！");
} else {
System.out.println("文件删除失败！");
}
}
}
输出结果：
文件不存在！ 文件创建成功！ 是否是文件：true 是否是目录：false 文件的名称：test.txt 文件的路径：test.txt 文件的绝对路径：C:\Users\Administrator\Desktop\test.txt 文件的大小：0 字节 文件删除成功！
本章我们学习了 Java 的 IO 流，包括字节流和字符流。其中，字节流（FileInputStream、FileOutputStream）、字符流（FileReader、FileWriter）、缓冲流（BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter）是本章的重点内容。从下一章开始，我们将学习 Java 的多线程、网络编程等内容。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online