IO流，文件操作

参考

Java IO 基础知识总结 | JavaGuide

史上最骚最全最详细的IO流教程，没有之一！ - 宜春 - 博客园

零、io-流简介

IO 即 Input/Output，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。

Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

  • InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
  • OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

一、字节流

1. InputStream（字符输入流）

InputStream 常用方法：

  • read()：返回输入流中下一个字节的数据。返回的值介于 0 到 255 之间。如果未读取任何字节，则代码返回 -1 ，表示文件结束。
  • read(byte b[ ]) : 从输入流中读取一些字节存储到数组 b 中。如果数组 b 的长度为零，则不读取。如果没有可用字节读取，返回 -1。如果有可用字节读取，则最多读取的字节数最多等于 b.length ， 返回读取的字节数。这个方法等价于 read(b, 0, b.length)。
  • read(byte b[], int off, int len)：在read(byte b[ ]) 方法的基础上增加了 off 参数（偏移量）和 len 参数（要读取的最大字节数）。
  • skip(long n)：忽略输入流中的 n 个字节 ,返回实际忽略的字节数。
  • available()：返回输入流中可以读取的字节数。
  • close()：关闭输入流释放相关的系统资源。

从 Java 9 开始，InputStream 新增加了多个实用的方法：

  • readAllBytes()：读取输入流中的所有字节，返回字节数组。
  • readNBytes(byte[] b, int off, int len)：阻塞直到读取 len 个字节。
  • transferTo(OutputStream out)：将所有字节从一个输入流传递到一个输出流。

FileInputStream 是一个比较常用的字节输入流对象，可直接指定文件路径，可以直接读取单字节数据，也可以读取至字节数组中。

FileInputStream 代码示例：

try (InputStream fis = new FileInputStream("input.txt")) {System.out.println("Number of remaining bytes:"+ fis.available());int content;long skip = fis.skip(2);System.out.println("The actual number of bytes skipped:" + skip);System.out.print("The content read from file:");while ((content = fis.read()) != -1) {System.out.print((char) content);}
} catch (IOException e) {e.printStackTrace();
}

input.txt 文件内容：

输出：

Number of remaining bytes:11
The actual number of bytes skipped:2
The content read from file:JavaGuide

不过，一般我们是不会直接单独使用 FileInputStream ，通常会配合 BufferedInputStream（字节缓冲输入流，后文会讲到）来使用。

像下面这段代码在我们的项目中就比较常见，我们通过 readAllBytes() 读取输入流所有字节并将其直接赋值给一个 String 对象。

// 新建一个 BufferedInputStream 对象
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("input.txt"));
// 读取文件的内容并复制到 String 对象中
String result = new String(bufferedInputStream.readAllBytes());
System.out.println(result);

DataInputStream 用于读取指定类型数据，不能单独使用，必须结合其它流，比如 FileInputStream 。

FileInputStream fileInputStream = new FileInputStream("input.txt");
//必须将fileInputStream作为构造参数才能使用
DataInputStream dataInputStream = new DataInputStream(fileInputStream);
//可以读取任意具体的类型数据
dataInputStream.readBoolean();
dataInputStream.readInt();
dataInputStream.readUTF();

ObjectInputStream 用于从输入流中读取 Java 对象（反序列化），ObjectOutputStream 用于将对象写入到输出流(序列化)。

ObjectInputStream input = new ObjectInputStream(new FileInputStream("object.data"));
MyClass object = (MyClass) input.readObject();
input.close();

另外，用于序列化和反序列化的类必须实现 Serializable 接口，对象中如果有属性不想被序列化，使用 transient 修饰。

package com.fatfish.iostream;import java.io.*;
import java.util.Arrays;public class InputStreamDemo {public static void main(String[] args) {test1();test2();test3();test4();test5();test6();}private static void test6() {System.out.println("================================test6()================================");try (FileInputStream fileInputStream = new FileInputStream("test.txt")) {DataInputStream dataInputStream = new DataInputStream(fileInputStream);boolean b = dataInputStream.readBoolean();System.out.println(b);int i = dataInputStream.readInt();System.out.println(i);
//            String s = dataInputStream.readUTF();
//            System.out.println(s);} catch (IOException e) {e.printStackTrace();}}private static void test5() {System.out.println("================================test5()================================");try (InputStream inputStream = new FileInputStream("test.txt");BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream)) {long start = System.currentTimeMillis();byte[] bytes = bufferedInputStream.readAllBytes();for (byte aByte : bytes) {System.out.println((char) aByte);}String s = new String(bytes);System.out.println(s);long end = System.currentTimeMillis();System.out.println(end-start + "ms");} catch (IOException e) {e.printStackTrace();}}private static void test4() {System.out.println("================================test4()================================");try (InputStream inputStream = new FileInputStream("test.txt")) {byte[] bytes = new byte[1024];int len;while (inputStream.read(bytes, 0, len = Math.min(inputStream.available(), bytes.length)) > 0) {for (int i = 0; i < len; i++) {System.out.println((char) bytes[i]);}}} catch (IOException e) {e.printStackTrace();}}private static void test3() {System.out.println("================================test3()================================");try (InputStream inputStream = new FileInputStream("test.txt")) {byte[] bytes = new byte[1024];while (inputStream.read(bytes) > 0) {for (byte aByte : bytes) {System.out.println((char) aByte);}}} catch (IOException e) {e.printStackTrace();}}private static void test2() {System.out.println("================================test2()================================");try (InputStream inputStream = new FileInputStream("test.txt")) {int content;while ((content = inputStream.read()) != -1) {System.out.println((char) content);}} catch (IOException e) {e.printStackTrace();}}private static void test1() {System.out.println("================================test1()================================");try (InputStream inputStream = new FileInputStream("test.txt")) {int available = inputStream.available();System.out.println("available: " + available);int firstByte = inputStream.read();System.out.println("firstByte: " + firstByte);byte[] b = new byte[4];int count = inputStream.read(b);System.out.println("byteArrayCount: " + count + ", readToByteArray: " + Arrays.toString(b));int readToByteArrayByOffAndLen = inputStream.read(b, 0, 3);System.out.println("readToByteArrayByOffAndLen: " + readToByteArrayByOffAndLen + ", readToByteArray: " + Arrays.toString(b));long skip = inputStream.skip(2);System.out.println("skip: " + skip);available = inputStream.available();System.out.println("available: " + available);} catch (IOException e) {e.printStackTrace();}}
}

2. OutputStream（字符输出流）

OutputStream用于将数据（字节信息）写入到目的地（通常是文件），java.io.OutputStream抽象类是所有字节输出流的父类。

OutputStream 常用方法：

  • write(int b)：将特定字节写入输出流。
  • write(byte b[ ]) : 将数组b 写入到输出流，等价于 write(b, 0, b.length) 。
  • write(byte[] b, int off, int len) : 在write(byte b[ ]) 方法的基础上增加了 off 参数（偏移量）和 len 参数（要读取的最大字节数）。
  • flush()：刷新此输出流并强制写出所有缓冲的输出字节。
  • close()：关闭输出流释放相关的系统资源。

FileOutputStream 是最常用的字节输出流对象，可直接指定文件路径，可以直接输出单字节数据，也可以输出指定的字节数组。

FileOutputStream 代码示例：

try (FileOutputStream output = new FileOutputStream("output.txt")) {byte[] array = "JavaGuide".getBytes();output.write(array);
} catch (IOException e) {e.printStackTrace();
}

运行结果：

类似于 FileInputStream，FileOutputStream 通常也会配合 BufferedOutputStream（字节缓冲输出流，后文会讲到）来使用。

FileOutputStream fileOutputStream = new FileOutputStream("output.txt");
BufferedOutputStream bos = new BufferedOutputStream(fileOutputStream)

DataOutputStream 用于写入指定类型数据，不能单独使用，必须结合其它流，比如 FileOutputStream 。

// 输出流
FileOutputStream fileOutputStream = new FileOutputStream("out.txt");
DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
// 输出任意数据类型
dataOutputStream.writeBoolean(true);
dataOutputStream.writeByte(1);

ObjectInputStream 用于从输入流中读取 Java 对象（ObjectInputStream,反序列化），ObjectOutputStream将对象写入到输出流(ObjectOutputStream，序列化)。

ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("file.txt")
Person person = new Person("Guide哥", "JavaGuide作者");
output.writeObject(person);

package com.fatfish.iostream;import com.fatfish.iostream.dto.Person;import java.io.*;/*** @author 24716* @version 1.0* @date 2024/6/5 21:23*/
public class OutputStreamDemo {public static void main(String[] args) {test1();test2();test3();test4();}private static void test4() {System.out.println("================================序列化与反序列化================================");try (OutputStream outputStream = new FileOutputStream("personData.txt");ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);InputStream inputStream = new FileInputStream("personData.txt");ObjectInputStream objectInputStream = new ObjectInputStream(inputStream)) {// 序列化Person person = new Person(1, "zhangsan", 35);objectOutputStream.writeObject(person);objectOutputStream.flush();// 反序列化Object object = objectInputStream.readObject();if (object instanceof Person) {System.out.println((Person) object);}} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}}private static void test3() {System.out.println("================================DataOutputStream================================");try (OutputStream outputStream = new FileOutputStream("outputFile.txt");DataOutputStream dataOutputStream = new DataOutputStream(outputStream)) {// 将特定字节写入输出流，写入 (char) intdataOutputStream.write(97);// 写入字节数组byte[] bytes = "Hello IOStream!".getBytes();dataOutputStream.write(bytes);dataOutputStream.write(bytes, 6, bytes.length - 6);// 写入任意数据类型dataOutputStream.writeBoolean(true);dataOutputStream.writeBoolean(false);
//            dataOutputStream.writeDouble(1.2345); // 确保在读取时使用正确的方法来解析二进制数据，而不是将其视为字符数据进行解码。否则乱码dataOutputStream.writeByte(98);dataOutputStream.writeBytes("xyz");// 强制将缓冲区中的数据写入目标位置dataOutputStream.flush();} catch (IOException e) {e.printStackTrace();}}private static void test2() {System.out.println("================================BufferedOutputStream================================");try (OutputStream outputStream = new FileOutputStream("outputFile.txt");BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream)) {// 将特定字节写入输出流，写入 (char) intbufferedOutputStream.write(97);// 写入字节数组byte[] bytes = "Hello IOStream!".getBytes();bufferedOutputStream.write(bytes);bufferedOutputStream.write(bytes, 6, bytes.length - 6);// 强制将缓冲区中的数据写入目标位置bufferedOutputStream.flush();} catch (IOException e) {e.printStackTrace();}}private static void test1() {System.out.println("================================OutputStream 常用方法================================");try (OutputStream outputStream = new FileOutputStream("outputFile.txt")) {// 将特定字节写入输出流，写入 (char) intoutputStream.write(97);// 写入字节数组byte[] bytes = "Hello IOStream!".getBytes();outputStream.write(bytes);outputStream.write(bytes, 6, bytes.length - 6);// 强制将缓冲区中的数据写入目标位置outputStream.flush();} catch (IOException e) {e.printStackTrace();}}
}

二、字符流

不管是文件读写还是网络发送接收，信息的最小存储单元都是字节。 那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

个人认为主要有两点原因：

  • 字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时。
  • 如果我们不知道编码类型就很容易出现乱码问题。
  1. 字节流操作（Byte Stream Operations）：
  • 字节流操作以字节为单位进行读取和写入，适用于处理二进制数据，如图像、音频、视频等。
  • 字节流操作不对数据进行任何解释或转换，直接处理数据的原始字节表示。
  • 字节流通常用于处理二进制文件或网络流，因为它们不对数据进行修改，能够直接传输数据的原始形式。
  1. 字符流操作（Character Stream Operations）：
  • 字符流操作以字符为单位进行读取和写入，适用于处理文本数据。
  • 字符流操作会将字节转换为字符，并根据指定的字符编码进行解码或编码。
  • 字符流通常用于处理文本文件或网络通信中的文本数据，因为它们能够正确地处理字符编码和字符集，避免了乱码等问题。

所以，尽管信息的存储和传输都是以字节为单位的，但在实际处理数据时，我们需要根据数据的类型和特性选择合适的流操作。字节流操作适用于处理二进制数据，而字符流操作适用于处理文本数据。这样做能够更加方便、高效地处理不同类型的数据，并确保数据在传输和处理过程中的完整性和正确性。

乱码问题这个很容易就可以复现，我们只需要将上面提到的 FileInputStream 代码示例中的 input.txt 文件内容改为中文即可，原代码不需要改动。

输出：

Number of remaining bytes:9
The actual number of bytes skipped:2
The content read from file:§å®¶å¥½

可以很明显地看到读取出来的内容已经变成了乱码。

因此，I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

字符流默认采用的是 Unicode 编码，我们可以通过构造方法自定义编码。顺便分享一下之前遇到的笔试题：常用字符编码所占字节数？

  • utf8 :英文占 1 字节，中文占 3 字节

  • unicode：任何字符都占 2 个字节

  • gbk：英文占 1 字节，中文占 2 字节。

1. Reader（字符输入流）

Reader用于从源头（通常是文件）读取数据（字符信息）到内存中，java.io.Reader抽象类是所有字符输入流的父类。

Reader 用于读取文本， InputStream 用于读取原始字节。

Reader 常用方法：

  • read() : 从输入流读取一个字符。
  • read(char[] cbuf) : 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中，等价于 read(cbuf, 0, cbuf.length) 。
  • read(char[] cbuf, int off, int len)：在read(char[] cbuf) 方法的基础上增加了 off 参数（偏移量）和 len 参数（要读取的最大字符数）。
  • skip(long n)：忽略输入流中的 n 个字符 ,返回实际忽略的字符数。
  • close() : 关闭输入流并释放相关的系统资源。

InputStreamReader 是字节流转换为字符流的桥梁，其子类 FileReader 是基于该基础上的封装，可以直接操作字符文件。

// 字节流转换为字符流的桥梁
public class InputStreamReader extends Reader {
}
// 用于读取字符文件
public class FileReader extends InputStreamReader {
}

FileReader 代码示例：

try (FileReader fileReader = new FileReader("input.txt");) {int content;long skip = fileReader.skip(3);System.out.println("The actual number of bytes skipped:" + skip);System.out.print("The content read from file:");while ((content = fileReader.read()) != -1) {System.out.print((char) content);}
} catch (IOException e) {e.printStackTrace();
}

input.txt 文件内容：

输出：

The actual number of bytes skipped:3
The content read from file:我是Guide。

package com.fatfish.iostream;import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Arrays;/*** @author fatfish* @version 1.0* @date 2024/6/5 22:14*/
public class FileReaderDemo {public static void main(String[] args) {test1();test2();}private static void test2() {System.out.println("=================================Reader()全文读取=================================");try (Reader reader = new FileReader("test.txt")) {int content;while ((content = reader.read()) != -1) {System.out.println((char) content);}} catch (IOException e) {e.printStackTrace();}}private static void test1() {System.out.println("=================================Reader()常用方法=================================");try (Reader reader = new FileReader("test.txt")) {long skip = reader.skip(2);int readACharacter = reader.read();System.out.println("readACharacter: " + readACharacter);char[] chars = new char[5];int readCnt = reader.read(chars);System.out.println("读取至字符数组：" + Arrays.toString(chars));readCnt = reader.read(chars, 0, 2);System.out.println("读取" + readCnt + "个字符至字符数组：" + Arrays.toString(chars));} catch (IOException e) {e.printStackTrace();}}
}

2. Writer（字符输出流）

Writer用于将数据（字符信息）写入到目的地（通常是文件），java.io.Writer抽象类是所有字符输出流的父类。

Writer 常用方法：

  • write(int c) : 写入单个字符。
  • write(char[] cbuf)：写入字符数组 cbuf，等价于write(cbuf, 0, cbuf.length)。
  • write(char[] cbuf, int off, int len)：在write(char[] cbuf) 方法的基础上增加了 off 参数（偏移量）和 len 参数（要读取的最大字符数）。
  • write(String str)：写入字符串，等价于 write(str, 0, str.length()) 。
  • write(String str, int off, int len)：在write(String str) 方法的基础上增加了 off 参数（偏移量）和 len 参数（要读取的最大字符数）。
  • append(CharSequence csq)：将指定的字符序列附加到指定的 Writer 对象并返回该 Writer 对象。
  • append(char c)：将指定的字符附加到指定的 Writer 对象并返回该 Writer 对象。
  • flush()：刷新此输出流并强制写出所有缓冲的输出字符。
  • close():关闭输出流释放相关的系统资源。

OutputStreamWriter 是字符流转换为字节流的桥梁，其子类 FileWriter 是基于该基础上的封装，可以直接将字符写入到文件。

// 字符流转换为字节流的桥梁
public class OutputStreamWriter extends Writer {
}
// 用于写入字符到文件
public class FileWriter extends OutputStreamWriter {
}

FileWriter 代码示例：

try (Writer output = new FileWriter("output.txt")) {output.write("你好，我是Guide。");
} catch (IOException e) {e.printStackTrace();
}

输出结果：

package com.fatfish.iostream;import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;/*** @author fatfish* @version 1.0* @date 2024/6/5 22:26*/
public class WriterDemo {public static void main(String[] args) {try (Writer writer = new FileWriter("outputFile.txt")) {writer.write(97);writer.write("你好世界！".toCharArray());writer.write("你好世界！".toCharArray(), 2, 2);writer.write("生活真美好。");writer.write("生活真美好。", 3, 2);writer.append("天天向上");writer.flush();} catch (IOException e) {e.printStackTrace();}}
}

三、缓冲流

1. 字节缓冲流

IO 操作是很消耗性能的，缓冲流将数据加载至缓冲区，一次性读取/写入多个字节，从而避免频繁的 IO 操作，提高流的传输效率。

字节缓冲流这里采用了装饰器模式来增强 InputStream 和OutputStream子类对象的功能。

举个例子，我们可以通过 BufferedInputStream（字节缓冲输入流）来增强 FileInputStream 的功能。

// 新建一个 BufferedInputStream 对象
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("input.txt"));

字节流和字节缓冲流的性能差别主要体现在我们使用两者的时候都是调用 write(int b) 和 read() 这两个一次只读取一个字节的方法的时候。由于字节缓冲流内部有缓冲区（字节数组），因此，字节缓冲流会先将读取到的字节存放在缓存区，大幅减少 IO 次数，提高读取效率。

我使用 write(int b) 和 read() 方法，分别通过字节流和字节缓冲流复制一个 524.9 mb 的 PDF 文件耗时对比如下：

使用缓冲流复制PDF文件总耗时:15428 毫秒
使用普通字节流复制PDF文件总耗时:2555062 毫秒

两者耗时差别非常大，缓冲流耗费的时间是字节流的 1/165。

测试代码如下:

@Test
void copy_pdf_to_another_pdf_buffer_stream() {// 记录开始时间long start = System.currentTimeMillis();try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("深入理解计算机操作系统.pdf"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("深入理解计算机操作系统-副本.pdf"))) {int content;while ((content = bis.read()) != -1) {bos.write(content);}} catch (IOException e) {e.printStackTrace();}// 记录结束时间long end = System.currentTimeMillis();System.out.println("使用缓冲流复制PDF文件总耗时:" + (end - start) + " 毫秒");
}@Test
void copy_pdf_to_another_pdf_stream() {// 记录开始时间long start = System.currentTimeMillis();try (FileInputStream fis = new FileInputStream("深入理解计算机操作系统.pdf");FileOutputStream fos = new FileOutputStream("深入理解计算机操作系统-副本.pdf")) {int content;while ((content = fis.read()) != -1) {fos.write(content);}} catch (IOException e) {e.printStackTrace();}// 记录结束时间long end = System.currentTimeMillis();System.out.println("使用普通流复制PDF文件总耗时:" + (end - start) + " 毫秒");
}

如果是调用 read(byte b[]) 和 write(byte b[], int off, int len) 这两个写入一个字节数组的方法的话，只要字节数组的大小合适，两者的性能差距其实不大，基本可以忽略。

这次我们使用 read(byte b[]) 和 write(byte b[], int off, int len) 方法，分别通过字节流和字节缓冲流复制一个 524.9 mb 的 PDF 文件耗时对比如下：

使用缓冲流复制PDF文件总耗时:695 毫秒
使用普通字节流复制PDF文件总耗时:989 毫秒

两者耗时差别不是很大，缓冲流的性能要略微好一点点。

测试代码如下：

@Test
void copy_pdf_to_another_pdf_with_byte_array_buffer_stream() {// 记录开始时间long start = System.currentTimeMillis();try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("深入理解计算机操作系统.pdf"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("深入理解计算机操作系统-副本.pdf"))) {int len;byte[] bytes = new byte[4 * 1024];while ((len = bis.read(bytes)) != -1) {bos.write(bytes, 0, len);}} catch (IOException e) {e.printStackTrace();}// 记录结束时间long end = System.currentTimeMillis();System.out.println("使用缓冲流复制PDF文件总耗时:" + (end - start) + " 毫秒");
}@Test
void copy_pdf_to_another_pdf_with_byte_array_stream() {// 记录开始时间long start = System.currentTimeMillis();try (FileInputStream fis = new FileInputStream("深入理解计算机操作系统.pdf");FileOutputStream fos = new FileOutputStream("深入理解计算机操作系统-副本.pdf")) {int len;byte[] bytes = new byte[4 * 1024];while ((len = fis.read(bytes)) != -1) {fos.write(bytes, 0, len);}} catch (IOException e) {e.printStackTrace();}// 记录结束时间long end = System.currentTimeMillis();System.out.println("使用普通流复制PDF文件总耗时:" + (end - start) + " 毫秒");
}

1.1 BufferedInputStream（字节缓冲输入流）

BufferedInputStream 从源头（通常是文件）读取数据（字节信息）到内存的过程中不会一个字节一个字节的读取，而是会先将读取到的字节存放在缓存区，并从内部缓冲区中单独读取字节。这样大幅减少了 IO 次数，提高了读取效率。

BufferedInputStream 内部维护了一个缓冲区，这个缓冲区实际就是一个字节数组，通过阅读 BufferedInputStream 源码即可得到这个结论。

public class BufferedInputStream extends FilterInputStream {// 内部缓冲区数组protected volatile byte buf[];// 缓冲区的默认大小private static int DEFAULT_BUFFER_SIZE = 8192;// 使用默认的缓冲区大小public BufferedInputStream(InputStream in) {this(in, DEFAULT_BUFFER_SIZE);}// 自定义缓冲区大小public BufferedInputStream(InputStream in, int size) {super(in);if (size <= 0) {throw new IllegalArgumentException("Buffer size <= 0");}buf = new byte[size];}
}

缓冲区的大小默认为 8192 字节，当然了，你也可以通过 BufferedInputStream(InputStream in, int size) 这个构造方法来指定缓冲区的大小。

1.2 BufferedOutputStream（字节缓冲输出流）

BufferedOutputStream 将数据（字节信息）写入到目的地（通常是文件）的过程中不会一个字节一个字节的写入，而是会先将要写入的字节存放在缓存区，并从内部缓冲区中单独写入字节。这样大幅减少了 IO 次数，提高了读取效率

try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {byte[] array = "JavaGuide".getBytes();bos.write(array);
} catch (IOException e) {e.printStackTrace();
}

类似于 BufferedInputStream ，BufferedOutputStream 内部也维护了一个缓冲区，并且，这个缓存区的大小也是 8192 字节。

2. 字符缓冲流

BufferedReader （字符缓冲输入流）和 BufferedWriter（字符缓冲输出流）类似于 BufferedInputStream（字节缓冲输入流）和BufferedOutputStream（字节缓冲输入流），内部都维护了一个字节数组作为缓冲区。不过，前者主要是用来操作字符信息。

四、打印流

下面这段代码大家经常使用吧？

System.out.print("Hello！");
System.out.println("Hello！");

System.out 实际是用于获取一个 PrintStream 对象，print方法实际调用的是 PrintStream 对象的 write 方法。

PrintStream 属于字节打印流，与之对应的是 PrintWriter （字符打印流）。PrintStream 是 OutputStream 的子类，PrintWriter 是 Writer 的子类。

public class PrintStream extends FilterOutputStreamimplements Appendable, Closeable {
}
public class PrintWriter extends Writer {
}

五、随机访问流

这里要介绍的随机访问流指的是支持随意跳转到文件的任意位置进行读写的 RandomAccessFile 。

RandomAccessFile 的构造方法如下，我们可以指定 mode（读写模式）。

// openAndDelete 参数默认为 false 表示打开文件并且这个文件不会被删除
public RandomAccessFile(File file, String mode)throws FileNotFoundException {this(file, mode, false);
}
// 私有方法
private RandomAccessFile(File file, String mode, boolean openAndDelete)  throws FileNotFoundException{// 省略大部分代码
}

读写模式主要有下面四种：

  • r : 只读模式。
  • rw: 读写模式
  • rws: 相对于 rw，rws 同步更新对“文件的内容”或“元数据”的修改到外部存储设备。
  • rwd : 相对于 rw，rwd 同步更新对“文件的内容”的修改到外部存储设备。

文件内容指的是文件中实际保存的数据，元数据则是用来描述文件属性比如文件的大小信息、创建和修改时间。

RandomAccessFile 中有一个文件指针用来表示下一个将要被写入或者读取的字节所处的位置。我们可以通过 RandomAccessFile 的 seek(long pos) 方法来设置文件指针的偏移量（距文件开头 pos 个字节处）。如果想要获取文件指针当前的位置的话，可以使用 getFilePointer() 方法。

RandomAccessFile 代码示例：

RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), "rw");
System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
// 指针当前偏移量为 6
randomAccessFile.seek(6);
System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
// 从偏移量 7 的位置开始往后写入字节数据
randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'});
// 指针当前偏移量为 0，回到起始位置
randomAccessFile.seek(0);
System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());

input.txt 文件内容：

输出：

读取之前的偏移量：0,当前读取到的字符A，读取之后的偏移量：1
读取之前的偏移量：6,当前读取到的字符G，读取之后的偏移量：7
读取之前的偏移量：0,当前读取到的字符A，读取之后的偏移量：1

input.txt 文件内容变为 ABCDEFGHIJK 。

RandomAccessFile 的 write 方法在写入对象的时候如果对应的位置已经有数据的话，会将其覆盖掉。

RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), "rw");
randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'});

假设运行上面这段程序之前 input.txt 文件内容变为 ABCD ，运行之后则变为 HIJK 。

断点续传

RandomAccessFile 比较常见的一个应用就是实现大文件的 断点续传 。何谓断点续传？简单来说就是上传文件中途暂停或失败（比如遇到网络问题）之后，不需要重新上传，只需要上传那些未成功上传的文件分片即可。分片（先将文件切分成多个文件分片）上传是断点续传的基础。

RandomAccessFile 可以帮助我们合并文件分片，示例代码如下：

我在《Java 面试指北》open in new window中详细介绍了大文件的上传问题。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/22945.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

2024年OceanBase数据库中级培训课程

2024年OceanBase数据库中级培训课程

课程概述 本课程主要讲解 OceanBase 的高级特性&#xff08;全局索引、全局数据一致性、负载均衡策略、SQL 引擎优化&#xff09;&#xff0c;以及 OceanBase 内存构成、内存数据落盘策略和 HTAP 等知识&#xff0c;同时提供了进阶实验课程。通过培训&#xff0c;学员将深入了…
阅读更多...
[沫忘录]MySQL InnoDB引擎

[沫忘录]MySQL InnoDB引擎

[沫忘录]MySQL InnoDB引擎 逻辑存储结构 InnoDB采用 “表、段&#xff0c;区&#xff0c; 页、行” 这样的层级结构进行存储。 **表空间(tablespace)**ibd文件&#xff0c;主要用于存储记录、索引等数据&#xff0c;一个mysql实例可有多个表空间&#xff0c;甚至能通过innodb…
阅读更多...
【机器学习】深度探索：从基础概念到深度学习关键技术的全面解析——梯度下降、激活函数、正则化与批量归一化

【机器学习】深度探索：从基础概念到深度学习关键技术的全面解析——梯度下降、激活函数、正则化与批量归一化

&#x1f525; 个人主页&#xff1a;空白诗 文章目录 一、机器学习的基本概念与原理二、深度学习与机器学习的关系2.1 概念层次的关系2.2 技术特点差异2.3 机器学习示例&#xff1a;线性回归&#xff08;使用Python和scikit-learn库&#xff09;2.4 深度学习示例&#xff1a;简…
阅读更多...
Cookie，Session与Token解析

Cookie，Session与Token解析

前言 在进行用户的授权认证时主要可以有三种方式&#xff0c;分别是Cookie&#xff0c;Session与Token&#xff0c;本文将对它们进行简要的介绍并总结他们三者之间的区别。 Cookie 首先&#xff0c;什么是Cookie? 简而言之&#xff0c;Cookie就是是一些数据&#xff0c;类型…
阅读更多...
在cmd菜单中使用自定义命令通过bat和powershell命令调用翻译API

在cmd菜单中使用自定义命令通过bat和powershell命令调用翻译API

先说一个血淋淋的结果&#xff0c;这个小功能其实在github已经有大佬帮我们封装好了&#xff0c;我也是自己刚倒腾好之后才发现的&#xff0c;所以如果只是需要这个功能的朋友可以直接移步这个项目&#xff1a;https://github.com/kenshinji/yddict&#xff0c;自己电脑安装一个…
阅读更多...
Linux 磁盘分区步骤

Linux 磁盘分区步骤

1.lsblk用于查看磁盘分区情况&#xff0c;lsblk -f用于查看uuid字符串以及挂载点。 以下是虚拟机部分添加磁盘的步骤。 其余没展示的都按照默认设置进入下一步即可。 2.添加完成后使用reboot重新进入后再使用lsblk就会发现磁盘sdb已经有了&#xff0c;但是没有分区。现在添加分…
阅读更多...
007 异步同步

007 异步同步

文章目录 异步、同步、阻塞和非阻塞是计算机科学中常用的术语&#xff0c;尤其在网络通信和多线程编程中。这些术语描述了不同的数据交换和处理方式。下面我将逐一解释这些概念&#xff1a; 异步&#xff08;Asynchronous&#xff09;与同步&#xff08;Synchronous&#xff0…
阅读更多...
三十六、openlayers官网示例Earthquake Clusters解析——在聚合图层鼠标触摸显示五角星

三十六、openlayers官网示例Earthquake Clusters解析——在聚合图层鼠标触摸显示五角星

官网demo地址&#xff1a; Earthquake Clusters 这篇展示了鼠标触摸聚合图层点位显示五角星的效果。 首先是初始化地图&#xff0c;加载了一个KML格式的矢量数据源&#xff0c;extractStyles为false表示不从kml数据源中提取样式。使用Select添加了鼠标选中的交互事件 vector …
阅读更多...
充电桩软硬件，赚钱新招数！

充电桩软硬件，赚钱新招数！

开源 | 愣子充电桩平台 | 慧哥充电桩平台V2.5.2&#xff08;支持 汽车 电动自行车 云快充1.5、云快充1.6 微服务 &#xff09;https://liwenhui.blog.csdn.net/article/details/134773779?spm1001.2014.3001.5502 充电桩软件和硬件一体化的盈利方向可以清晰地归纳为以下几个主…
阅读更多...
【Kubernetes】 emptyDir、nfs存储卷 和 PV、PVC

【Kubernetes】 emptyDir、nfs存储卷 和 PV、PVC

emptyDir存储卷 当pod被分配给节点 容器和容器之间进行共享存储 hostPath nfs共享存储卷 NAS 专业的存储设备&#xff1b;一般是与NFS 搭配&#xff0c;然后共享出去 GFS 自己搭&#xff1b;CEPH(至少要9台) 第三方&#xff1b;NAS 第三方&#xff1b; 云端 oss …
阅读更多...
【wiki知识库】05.分类管理模块--后端SpringBoot模块

【wiki知识库】05.分类管理模块--后端SpringBoot模块

&#x1f4dd;个人主页&#xff1a;哈__ 期待您的关注 目录 一、&#x1f525;今日目标 二、☀SpringBoot代码修改 1.使用逆向工程生成Category表结构 2. 新增CategoryQueryParam 3.新增CategorySaveParam 4.新增CategotyQueryVo 三、&#x1f916;新增分类管理的相关接口…
阅读更多...
学习分享-面向分布式服务架构的流量管理工具Apache Sentinel

学习分享-面向分布式服务架构的流量管理工具Apache Sentinel

前言 最近学习过程中有接触到Apache Sentinel这个工具&#xff0c;所以就分享一下相关的资料和知识。 Apache Sentinel是阿里巴巴开源的一款面向分布式服务架构的流量管理工具&#xff0c;主要用于流量控制、熔断降级和系统负载保护。Sentinel提供了一整套完善的流量管理方案&…
阅读更多...
人脸识别系统代码--相机抓取

人脸识别系统代码--相机抓取

1.导入库 import cv2 import os import tkinter as tk from tkinter import filedialog import subprocess from PIL import Image, ImageTk 2.设置窗口 win tk.Tk() win.title(相机抓取) win.geometry(750x600) 3.设置背景 image Image.open("11.gif") image…
阅读更多...
v1.2.70-FastJson的AutoType机制研究

v1.2.70-FastJson的AutoType机制研究

v1.2.70-FastJson的AutoType机制研究 最近在对接Alexa亚马逊语音技能&#xff0c;Smart Home Skill Apis时&#xff0c;有一个配置的JSON字符串是这样的&#xff1a; { "capabilityResources": {"friendlyNames": [{"type": "asset",…
阅读更多...
python图像识别库-pytesseract

python图像识别库-pytesseract

内容目录 一、安装1.安装tesseract OCR1) MAC中安装2) Windows中安装3) 中文报下载 二、pytesseract的简单使用 pytesseract是python的一个用于图像提取的库, 它实际上是对Tesseract OCR引擎的封装。pytesseract使得在Python项目中调用Tesseract变得更加简便&#xff0c;主要用…
阅读更多...
17K star，一款开源免费的手机电脑无缝同屏软件

17K star，一款开源免费的手机电脑无缝同屏软件

导读&#xff1a;白茶清欢无别事&#xff0c;我在等风也等你。 作为程序员&#xff0c;在我们的工作中经常需要把手机投票到电脑进行调试工作&#xff0c;选择一款功能强大的投屏软件是一件很必要的事情。今天给大家介绍一款开源且免费的投屏软件&#xff0c;极限投屏&#xff…
阅读更多...
Arthas调优工具使用

Arthas调优工具使用

1&#xff0c;服务器端下载 curl -O https://arthas.aliyun.com/arthas-boot.jar 2&#xff0c;服务器端启动 java -jar arthas-boot.jar 选定要绑定的Java进程ID 3&#xff0c;本地idea安装Arthas idea 4&#xff0c;选定方法右键trace,生成命令 trace com.xxx.xxx.xxx.vouche…
阅读更多...
C语言数据结构快速排序的非递归、归并排序、归并排序的非递归等的介绍

C语言数据结构快速排序的非递归、归并排序、归并排序的非递归等的介绍

文章目录 前言一、快速排序非递归二、归并排序五、归并排序非递归总结 前言 C语言数据结构快速排序的非递归、归并排序、归并排序的非递归等的介绍 一、快速排序非递归 快速排序非递归的定义 快速排序非递归&#xff0c;需要使用栈来实现。将左右下标分别push到栈中。在栈为…
阅读更多...
处理机调度

处理机调度

目录 处理机调度概述 1. 作业调度&#xff08;Job Scheduling&#xff09; 2. 中级调度&#xff08;Medium-term Scheduling&#xff09; 3. 进程调度&#xff08;Process Scheduling&#xff09; 调度算法 1. 先来先服务&#xff08;FCFS&#xff09; 2. 最短作业优先&a…
阅读更多...
基于Tricore的Tasking链接文件解读

基于Tricore的Tasking链接文件解读

目录 1.链接文件有什么用&#xff1f; 2.文件结构和语法解析 2.1 文件结构 2.2 语法解析 3.小结 玩惯了ld文件&#xff0c;突然让搞lsl&#xff0c;被其中花里胡哨的语法搞晕了&#xff0c;例如&#xff1a; memory cpu0_dlmu{mau 8;size 64k;type ram;map cached …
阅读更多...
最新文章

Copyright @ 2022~2023