Java 中 IO 流

FileInputStream fis = new FileInputStream("example.txt");
int data = fis.read();
while (data != -1) {
    // 处理读取的字节数据
    System.out.print((char) data);
    data = fis.read();
}
fis.close();

ByteArrayInputStream: 从字节数组读取字节。

byte[] byteArray = {65, 66, 67, 68, 69}; // ASCII values for A, B, C, D, E
ByteArrayInputStream bais = new ByteArrayInputStream(byteArray);
int data = bais.read();
while (data != -1) {
    // 处理读取的字节数据
    System.out.print((char) data);
    data = bais.read();
}
bais.close();

BufferedInputStream: 提供缓冲功能，提高读取效率。

FileInputStream fis = new FileInputStream("example.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
int data = bis.read();
while (data != -1) {
    // 处理读取的字节数据
    System.out.print((char) data);
    data = bis.read();
}
bis.close();

1.2 输出字节流：

OutputStream（输出流的抽象基类）：

FileOutputStream: 向文件写入字节。

FileOutputStream fos = new FileOutputStream("output.txt");
fos.write("Hello, World!".getBytes());
fos.close();

ByteArrayOutputStream: 将字节写入到字节数组。

ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write("Hello, World!".getBytes());
byte[] result = baos.toByteArray();
baos.close();

BufferedOutputStream: 提供缓冲功能，提高写入效率。

FileOutputStream fos = new FileOutputStream("output.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("Hello, World!".getBytes());
bos.close();

2. 字符流（Character Streams）：

字符流以字符为单位进行读写操作，适用于处理文本数据。

2.1 输入字符流：

Reader（输入流的抽象基类）：

FileReader: 从文件读取字符。

FileReader fr = new FileReader("example.txt");
int data = fr.read();
while (data != -1) {
    // 处理读取的字符数据
    System.out.print((char) data);
    data = fr.read();
}
fr.close();

CharArrayReader: 从字符数组读取字符。

char[] charArray = {'A', 'B', 'C', 'D', 'E'};
CharArrayReader car = new CharArrayReader(charArray);
int data = car.read();
while (data != -1) {
    // 处理读取的字符数据
    System.out.print((char) data);
    data = car.read();
}
car.close();

BufferedReader: 提供缓冲功能，提高读取效率。

FileReader fr = new FileReader("example.txt");
BufferedReader br = new BufferedReader(fr);
String line = br.readLine();
while (line != null) {
    // 处理读取的一行字符数据
    System.out.println(line);
    line = br.readLine();
}
br.close();

2.2 输出字符流：

Writer（输出流的抽象基类）：

FileWriter: 向文件写入字符。

FileWriter fw = new FileWriter("output.txt");
fw.write("Hello, World!");
fw.close();

CharArrayWriter: 将字符写入到字符数组。

CharArrayWriter caw = new CharArrayWriter();
caw.write("Hello, World!");
char[] result = caw.toCharArray();
caw.close();

BufferedWriter: 提供缓冲功能，提高写入效率。

FileWriter fw = new FileWriter("output.txt");
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Hello, World!");
bw.close();

3. 转换流（转换流用于连接字节流和字符流）：

InputStreamReader： 将字节输入流转换为字符输入流。

FileInputStream fis = new FileInputStream("example.txt");
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
BufferedReader br = new BufferedReader(isr);
// 通过 BufferedReader 读取字符数据
br.close();

OutputStreamWriter： 将字节输出流转换为字符输出流。

FileOutputStream fos = new FileOutputStream("output.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
// 通过 BufferedWriter 写入字符数据
bw.close();

4. 对象流：

ObjectInputStream： 用于读取对象的输入流。

FileOutputStream fos = new FileOutputStream("object.dat");
ObjectOutputStream oos = new ObjectOutputStream(fos);

MyClass obj = new MyClass(); // MyClass需要实现Serializable接口
oos.writeObject(obj);

oos.close();

ObjectOutputStream： 用于写入对象的输出流。

FileInputStream fis = new FileInputStream("object.dat");
ObjectInputStream ois = new ObjectInputStream(fis);

MyClass obj = (MyClass) ois.readObject(); // 强制类型转换为实际的对象类型

ois.close();