一文搞定Java IO流，输入流、输出流、字符流、缓冲流，附详细代码示例
目录
-
- 一、InputStream
-
- 1、FileInputStream的代码示例
- 2、ByteArrayInputStream的代码示例
- 3、PipedInputStream的代码示例
- 二、 OutputStream
-
- 1、FileOutputStream代码示例
- 2、ByteArrayOutputStream代码示例：
- 3、PipedOutputStream代码示例：
- 三、字符输入流Reader
-
- 1、FileReader 代码示例
- 2、InputStreamReader 代码示例
- 四、字符输出流Writer
-
- 1、FileWriter代码示例
- 2、OutputStreamWriter代码示例
- 五、缓冲流
-
- 缓冲流代码示例
- 六、对象流
-
- 对象流代码示例
大家好，我是哪吒。
很多朋友问我，如何才能学好IO流，对各种流的概念，云里雾里的，不求甚解。用到的时候，现百度，功能虽然实现了，但是为什么用这个？不知道。更别说效率问题了~
下次再遇到，再百度，“良性循环”。
今天，我就用一天的时间，整理一下关于Java I/O流的知识点，分享给大家。
每一种IO流，都配有示例代码，大家可以跟着敲一遍，找找感觉~
本文收录于：Java进阶教程系列。本专栏专门针对零基础和需要进阶提升的同学所准备的一套完整教学，从0开始，不断进阶深入，轻松应对面试。
Java I/O (Input/Output) 是对传统 I/O 操作的封装，它是以流的形式来操作数据的。在 I/O 操作中，数据被视为一系列按顺序排列的字节流。在 Java 中，这种字节流被称为 InputStream 和 OutputStream。
一、InputStream
InputStream 代表一个输入流，它是一个抽象类，不能被实例化。InputStream 定义了一些通用方法，如 read() 和 skip() 等，用于从输入流中读取数据。常用的 InputStream 实现类包括：
1、FileInputStream的代码示例
下面是使用 FileInputStream 读取文件内容的示例代码：
import java.io.*;
public class FileInputStreamExample {
public static void main(String[] args) {
// 要读取的文件路径和名称
String filePath = "C:/example/file.txt";
// 创建输入流对象
FileInputStream fis = null;
try {
fis = new FileInputStream(filePath);
byte[] buffer = new byte[1024];
int len;
// 使用 while 循环读取文件，每次最多读取 1024 个字节
while ((len = fis.read(buffer)) != -1) {
// 将读取的字节转换为字符串，并输出到控制台
String content = new String(buffer, 0, len, "UTF-8");
System.out.println(content);
}
} catch (FileNotFoundException e) {
System.out.println("File not found: " + filePath);
} catch (IOException e) {
System.out.println("Error reading file: " + e.getMessage());
} finally {
// 关闭输入流
try {
if (fis != null) {
fis.close();
}
} catch (IOException e) {
System.out.println("Error closing file: " + e.getMessage());
}
}
}
}
示例代码说明：
- 在示例中，我们首先指定要读取的文件路径和名称。在实际使用中，您应该将其替换为实际的文件路径和名称。
- 然后，我们使用文件路径创建一个FileInputStream对象。注意，在创建FileInputStream对象时，我们必须提供要读取的文件的路径和名称。
- 接着，我们使用while循环从FileInputStream对象中读取数据。每次循环中，我们使用read()方法读取最多1024字节，并将读取的字节存储在一个缓冲区中。然后，我们将读取的字节转换为字符串，并在控制台上输出。在while循环结束后，我们关闭FileInputStream对象。
- 注意：在使用FileInputStream类时，我们需要确保文件存在，并且我们有读取文件的权限。此外，在实际应用中，可能需要根据需要使用更高效的方法读取大型文件，以避免IO开销的问题。
2、ByteArrayInputStream的代码示例
下面是使用 ByteArrayInputStream 读取字节数组内容的示例代码：
import java.io.*;
public class ByteArrayInputStreamExample {
public static void main(String[] args) {
byte[] bytes = { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 };
// 创建字节输入流对象
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
try {
byte[] buffer = new byte[1024];
int len;
// 使用 while 循环读取字节数组中的内容，每次最多读取 1024 个字节
while ((len = bais.read(buffer)) != -1) {
// 将读取的字节转换为字符串，并输出到控制台
String content = new String(buffer, 0, len, "UTF-8");
System.out.println(content);
}
} catch (IOException e) {
System.out.println("Error reading byte array: " + e.getMessage());
} finally {
// 关闭输入流
try {
if (bais != null) {
bais.close();
}
} catch (IOException e) {
System.out.println("Error closing byte array input stream: " + e.getMessage());
}
}
}
}
示例代码说明:
- 在示例中，我们首先创建了一个字节数组，其中包含ASCII码为72, 101, 108, 108, 111, 32, 87, 111,
114, 108, 100, 33的字符序列"Hello World!"。 - 然后，我们使用字节数组创建了一个ByteArrayInputStream对象。注意，在创建ByteArrayInputStream对象时，我们必须提供要从中读取的字节数组。
- 接着，我们使用while循环从ByteArrayInputStream对象中读取数据。每次循环中，我们使用read()方法读取最多1024字节，并将读取的字节存储在一个缓冲区中。然后，我们将读取的字节转换为字符串，并在控制台上输出。在while循环结束后，我们关闭ByteArrayInputStream对象。
- 注意：在使用ByteArrayInputStream类时，字节数组是一次性全部加载到内存中的，如果字节数组较大，可能会导致内存不足的问题。此外，在实际应用中，可能需要使用更高效的数据源（如文件或网络流）来存储数据，以避免内存限制的问题。
3、PipedInputStream的代码示例
PipedInputStream：管道输入流，用于线程之间的通信。
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class PipedInputStreamExample {
public static void main(String[] args) throws Exception {
// 创建一对PipedInputStream和PipedOutputStream
PipedInputStream input = new PipedInputStream();
PipedOutputStream output = new PipedOutputStream(input);
// 创建一个写线程
Thread writerThread = new Thread(new Runnable() {
@Override
public void run() {
try {
// 写入一些数据到PipedOutputStream
output.write("Hello, World!".getBytes());
output.close(); // 关闭PipedOutputStream
} catch (IOException e) {
e.printStackTrace();
}
}
});
// 创建一个读线程
Thread readerThread = new Thread(new Runnable() {
@Override
public void run() {
try {
// 读取PipedInputStream中的数据
int data;
while ((data = input.read()) != -1) {
System.out.print((char) data); // 将数据打印到控制台
}
input.close(); // 关闭PipedInputStream
} catch (IOException e) {
e.printStackTrace();
}
}
});
// 启动写线程和读线程
writerThread.start();
readerThread.start();
// 等待写线程和读线程完成
writerThread.join();
readerThread.join();
}
}
代码说明
PipedInputStream和PipedOutputStream是Java IO库提供的一对管道流，可以用于数据的发送和接收。
- 在示例中，我们首先创建了一个PipedInputStream和一个PipedOutputStream。它们被连接在一起，使得我们可以像使用一个普通的输入流- 和输出流一样进行读写操作。
- 接着，我们创建一个写线程来向管道中写入数据。在这个例子中，我们写入了字符串"Hello, World!"。
- 然后，我们创建一个读线程来从管道中读取数据。我们使用了一个while循环来读取数据，直到遇到了流的末尾。
- 最后，我们启动写线程和读线程，等待它们完成，然后关闭流。
- 注意：如果读线程在数据被写入管道之前就开始读取流，它将会阻塞（即等待数据被写入）。
- 另外，还要注意线程之间的同步问题。在这个例子中，我们使用了一个简单的join()方法来等待写线程和读线程完成。在实际使用中，您可能需要使用更高级的同步机制来确保线程之间的正确协作。
二、 OutputStream
OutputStream 代表一个输出流，它也是一个抽象类，不能被实例化。OutputStream 定义了一些通用方法，如 write() 和 flush() 等，用于向输出流中写入数据。常用的 OutputStream 实现类包括：
1、FileOutputStream代码示例
文件输出流，用于向文件中写入数据。
import java.io.*;
public class FileOutputStreamExample {
public static void main(String[] args) {
// 要写入的文件路径和名称
String filePath = "C:/example/output.txt";
// 要写入文件的内容
String content = "Hello, World!";
// 创建输出流对象
FileOutputStream fos = null;
try {
fos = new FileOutputStream(filePath);
// 将字符串转换为字节数组，并将其写入文件
fos.write(content.getBytes("UTF-8"));
// 刷新输出流
fos.flush();
// 输出提示信息
System.out.println("Content has been written to " + filePath);
} catch (FileNotFoundException e) {
System.out.println("File not found: " + filePath);
} catch (IOException e) {
System.out.println("Error writing file: " + e.getMessage());
} finally {
// 关闭输出流
try {
if (fos != null) {
fos.close();
}
} catch (IOException e) {
System.out.println("Error closing file: " + e.getMessage());
}
}
}
}
示例代码说明:
- 在示例中，我们首先指定要写入的文件路径和名称。在实际使用中，您应该将其替换为实际的文件路径和名称。
- 然后，我们创建一个用于写入文件的输出流对象。在创建FileOutputStream对象时，如果文件不存在，Java将会自动创建它。
- 接着，我们将要写入的内容转换为字节数组，并使用write()方法将其写入文件。
- 然后，我们使用flush()方法刷新输出流。在文件操作完成后，我们应该始终调用flush()方法以确保所有数据都被写入到磁盘上的文件中。
- 最后，我们关闭FileOutputStream对象，即使在发生异常时也应该关闭。
- 注意：在使用FileOutputStream类时，我们需要确保文件存在，并且我们有写入文件的权限。此外，在实际应用中，可能需要使用更高效的方法来写入大型文件，以避免IO开销的问题。
2、ByteArrayOutputStream代码示例：
字节数组输出流，用于将数据写入内存中的字节数组中。
import java.io.*;
public class ByteArrayOutputStreamExample {
public static void main(String[] args) {
// 创建字节数组输出流对象
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
// 将字符串转换为字节数组，并写入到字节数组输出流中
baos.write("Hello, World!".getBytes("UTF-8"));
// 将字节数组输出流中的数据转换为字节数组
byte[] bytes = baos.toByteArray();
// 将字节数组转换为字符串，并输出到控制台
String content = new String(bytes, "UTF-8");
System.out.println(content);
} catch (IOException e) {
System.out.println("Error writing to byte array: " + e.getMessage());
} finally {
// 关闭字节数组输出流
try {
if (baos != null) {
baos.close();
}
} catch (IOException e) {
System.out.println("Error closing byte array output stream: " + e.getMessage());
}
}
}
}
示例代码说明:
- 在示例中，我们首先创建了一个ByteArrayOutputStream对象，用于向内存中的字节数组中写入数据。
- 然后，我们将要写入的内容转换为字节数组，并使用write()方法将其写入ByteArrayOutputStream对象。
- 接着，我们调用toByteArray()方法将ByteArrayOutputStream对象中的数据转换为字节数组。需要注意的是，要在调用toByteArray()方法之前先关闭ByteArrayOutputStream。
- 最后，我们将字节数组转换为字符串，并将其输出到控制台。
- 注意：在使用ByteArrayOutputStream类时，需要注意内存占用问题。BytesArrayOutputStream类主要用于在内存中临时存储数据。对于大数据，可能需要使用其他方式存储。
3、PipedOutputStream代码示例：
管道输出流，用于线程之间的通信。
import java.io.*;
public class PipedOutputStreamExample {
public static void main(String[] args) {
// 创建一对PipedInputStream和PipedOutputStream
PipedInputStream input = new PipedInputStream();
PipedOutputStream output = new PipedOutputStream();
try {
// 将输入流和输出流连接起来
input.connect(output);
// 创建一个写线程
Thread writerThread = new Thread(new Runnable() {
@Override
public void run() {
try {
// 写入一些数据到PipedOutputStream
output.write("Hello, World!".getBytes("UTF-8"));
// 刷新PipedOutputStream
output.flush();
// 关闭PipedOutputStream
output.close();
} catch (IOException e) {
System.out.println("Error writing to pipe: " + e.getMessage());
}
}
});
// 创建一个读线程
Thread readerThread = new Thread(new Runnable() {
@Override
public void run() {
try {
// 读取PipedInputStream中的数据
byte[] buffer = new byte[1024];
int len = input.read(buffer);
// 将读取的字节转换为字符串，并输出到控制台
String content = new String(buffer, 0, len, "UTF-8");
System.out.println(content);
// 关闭PipedInputStream
input.close();
} catch (IOException e) {
System.out.println("Error reading from pipe: " + e.getMessage());
}
}
});
// 启动写线程和读线程
writerThread.start();
readerThread.start();
// 等待写线程和读线程完成
writerThread.join();
readerThread.join();
} catch (IOException | InterruptedException e) {
System.out.println("Error communicating between threads: " + e.getMessage());
}
}
}
示例代码说明:
- 在示例中，我们首先创建了一对PipedInputStream和PipedOutputStream，用于在线程之间进行通信。
- 接着，我们使用connect()方法将PipedInputStream和PipedOutputStream连接起来。
- 然后，我们创建一个写线程和一个读线程。在写线程中，我们向PipedOutputStream写入数据，并使用flush()和close()方法刷新和关闭输出流。在读线程中，我们从PipedInputStream读取数据，并将其转换为字符串并打印到控制台。在读操作完成后，我们关闭输入流
- 最后，我们启动写线程和读线程，并等待它们完成。
- 注意：在使用PipedInputStream和PipedOutputStream类时，需要考虑线程同步问题，以确保在线程之间正确地交换数据。在实际应用中，您可能需要使用更高级的同步机制来确保线程之间的协作。
三、字符输入流Reader
除了字节流，Java 还提供字符流，字符流类似于字节流，不同之处在于字符流是按字符读写数据，而不是按字节。Java 中最基本的字符流是 Reader 和 Writer，它们是基于 InputStream 和 OutputStream 的转换类，用于完成字节流与字符流之间的转换。
常用的实现类包括 FileReader 和 InputStreamReader等
1、FileReader 代码示例
import java.io.FileReader; // 引入 FileReader 类
import java.io.IOException; // 引入 IOException 类
public class FileReaderExample {
public static void main(String[] args) {
// 定义文件路径
String filePath = "example.txt";
try {
// 创建 FileReader 对象
FileReader fileReader = new FileReader(filePath);
// 读取字符
int character;
while ((character = fileReader.read()) != -1) {
// 打印字符
System.out.print((char) character);
}
// 关闭 FileReader 对象
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
2、InputStreamReader 代码示例
import java.io.BufferedReader; // 引入 BufferedReader 类
import java.io.IOException; // 引入 IOException 类
import java.io.InputStreamReader; // 引入 InputStreamReader 类
public class InputStreamReaderExample {
public static void main(String[] args) {
try {
// 创建 InputStreamReader 对象
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
// 创建 BufferedReader 对象
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
// 获取用户输入
System.out.println("请输入字符串：");
String inputString = bufferedReader.readLine();
// 打印用户输入
System.out.println("您输入的字符串是：" + inputString);
// 关闭 BufferedReader 对象
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
四、字符输出流Writer
1、FileWriter代码示例
import java.io.*;
public class FileWriterExample {
public static void main(String[] args) {
FileWriter writer = null;
try {
writer = new FileWriter("example.txt");
writer.write("Hello World!");
writer.close();
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
} finally {
try {
if (writer != null)
writer.close();
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}
}
示例代码说明:
- 在这个例子中，创建了一个FileWriter对象 writer，并将字符串"Hello World!"写入文件
“example.txt”。然后，我们使用close()方法关闭写入器以确保所有的数据都被刷新到磁盘。 - 注意：在使用FileWriter时，要确保在不再需要它时关闭它以确保所有的字符都被刷新到文件中。如果您使用Java7或更高版本，可以考虑使用try-with-resources语句，这样您就不需要显式地关闭写入器。
2、OutputStreamWriter代码示例
import java.io.*;
public class OutputStreamWriterExample {
public static void main(String[] args) {
FileOutputStream outputStream = null;
OutputStreamWriter writer = null;
try {
outputStream = new FileOutputStream("example.txt");
writer = new OutputStreamWriter(outputStream, "UTF-8");
writer.write("Hello World!");
writer.close();
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
} finally {
try {
if (writer != null)
writer.close();
if (outputStream != null)
outputStream.close();
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}
}
示例代码说明:
- 在这个例子中，创建了一个FileOutputStream对象 outputStream 用于写入文件
“example.txt”。接着，创建了一个OutputStreamWriter对象 writer，它被用于将字符串"Hello
World!"写入到文件中。指定了"UTF-8"作为字符编码。 - 最后，使用close()方法关闭写入器和输出流以确保所有的数据都被刷新到磁盘上。
- 注意：在使用OutputStreamWriter时，要确保在不再需要它时关闭它以确保所有的字符都被刷新到文件中。如果您使用Java 7或更高版本，可以考虑使用try-with-resources语句，这样您就不需要显式地关闭写入器和输出流。
五、缓冲流
BufferedInputStream 和 BufferedOutputStream 是 I/O 包中提供的缓冲输入输出流。它们可以提高 I/O 操作的效率，具有较好的缓存机制，能够减少磁盘操作，缩短文件传输时间。使用 BufferedInputStream 和 BufferedOutputStream 进行读取和写入时，Java 会自动调整缓冲区的大小，使其能够适应不同的数据传输速度。
缓冲流代码示例
import java.io.BufferedInputStream; // 引入 BufferedInputStream 类
import java.io.BufferedOutputStream; // 引入 BufferedOutputStream 类
import java.io.FileInputStream; // 引入 FileInputStream 类
import java.io.FileOutputStream; // 引入 FileOutputStream 类
import java.io.IOException; // 引入 IOException 类
public class BufferedStreamsExample {
public static void main(String[] args) {
String sourceFile = "source.txt";
String targetFile = "target.txt";
try {
// 创建 BufferedInputStream 和 BufferedOutputStream 对象
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(sourceFile));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(targetFile));
// 读取数据，直到读取的内容为-1
int data;
while ((data = bufferedInputStream.read()) != -1) {
bufferedOutputStream.write(data);
}
// 关闭 BufferedInputStream 和 BufferedOutputStream 对象
bufferedInputStream.close();
bufferedOutputStream.close();
// 打印成功信息
System.out.println("复制文件成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
六、对象流
可以读取或写入 Java 对象的流，比较典型的对象流包括ObjectInputStream 和 ObjectOutputStream。
对象流需要将对象序列化和反序列化为字节序列，使用 ObjectInputStream 和 ObjectOutputStream 可以将 Java 对象转换为字节流进行传输或存储。
在网络传输和文件存储中，ObjectInputStream 和 ObjectOutputStream 通常会被使用到。
对象流代码示例
import java.io.FileInputStream; // 引入 FileInputStream 类
import java.io.FileOutputStream; // 引入 FileOutputStream 类
import java.io.ObjectInputStream; // 引入 ObjectInputStream 类
import java.io.ObjectOutputStream; // 引入 ObjectOutputStream 类
import java.io.Serializable; // 引入 Serializable 接口
class Person implements Serializable {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "姓名：" + name + "\n年龄：" + age;
}
}
public class ObjectStreamsExample {
public static void main(String[] args) {
String filePath = "person.dat";
// 创建 Person 对象
Person person = new Person("Alice", 20);
try {
// 创建 ObjectOutputStream 对象
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
// 将 Person 对象写入文件
objectOutputStream.writeObject(person);
// 关闭 ObjectOutputStream 对象
objectOutputStream.close();
// 创建 ObjectInputStream 对象
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
// 从文件中读取 Person 对象
Person personFromFile = (Person) objectInputStream.readObject();
// 关闭 ObjectInputStream 对象
objectInputStream.close();
// 打印读取的对象
System.out.println(personFromFile);
} catch (Exception e) {
e.printStackTrace();
}
}
}
本文收录于，Java进阶教程系列。
全网最细Java零基础手把手入门教程，系列课程包括：基础篇、集合篇、Java8新特性、多线程、代码实战，持续更新中（每周1-2篇），适合零基础和进阶提升的同学。
哪吒多年工作总结：Java学习路线总结，搬砖工逆袭Java架构师。