如何在不耗尽内存的前提下逐字符反向读取GB级大文件

核心思路 #

针对GB级单行UTF-8文件的反向读取需求，不需要加载全量文件内容，也不需要修改JDK原生流的native实现，基于UTF-8编码规则+固定大小缓冲区分块随机读即可实现，全程内存占用稳定在缓冲区大小级别（通常几KB到几十KB即可），完全不会触发OOM。

UTF-8是变长编码，每个字符的字节长度可以通过字节位特征直接判断，倒序读取时只要准确识别字符边界，就不会出现乱码：

• 单字节字符：首字节最高位为0，格式为0xxxxxxx
• 多字节字符：首字节最高位有连续n个1后接1个0（n为字符总字节数，UTF-8最长为4字节），后续所有尾随字节最高两位固定为10，格式为10xxxxxx

具体实现步骤 #

• 打开文件：使用RandomAccessFile以只读模式打开目标文件，调用length()方法获取文件总字节长度，将读指针初始定位到文件末尾。
• 分块读入：设置固定大小的读缓冲区（推荐8KB~64KB，可根据运行环境调整），每次将读指针向前移动缓冲区大小的偏移量，读取对应区间的字节到缓冲区中；如果剩余未读长度小于缓冲区大小，直接读取从文件头部到当前指针位置的所有字节即可。
• 缓冲区反向解析：从缓冲区的最后一个字节开始向前遍历：
  • 如果当前字节符合单字节字符特征，直接转码为字符输出，读指针前移1位
  • 如果当前字节是多字节字符的尾随字节（最高两位为10），持续向前遍历直到找到字符首字节，根据首字节的位特征计算该字符总字节长度，取出对应长度的连续字节转码为UTF-8字符输出，读指针前移对应字节长度
• 循环处理：重复分块读入、缓冲区解析的流程，直到读指针到达文件起始位置，读取完成。

核心参考代码 #

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;

public class ReverseUtf8Reader {
    private static final int BUF_SIZE = 8192; // 8KB固定缓冲区，内存占用无波动
    private final RandomAccessFile raf;
    private final long fileLen;
    private long fileReadPos;
    private final byte[] buf;
    private int bufPos;

    public ReverseUtf8Reader(String filePath) throws IOException {
        this.raf = new RandomAccessFile(filePath, "r");
        this.fileLen = raf.length();
        this.fileReadPos = fileLen;
        this.buf = new byte[BUF_SIZE];
        this.bufPos = -1;
    }

    // 反向读取下一个字符，读到文件头部时返回-1
    public int read() throws IOException {
        if (bufPos < 0) {
            if (fileReadPos == 0) return -1;
            // 计算本次读取的块长度
            int readLen = (int) Math.min(BUF_SIZE, fileReadPos);
            fileReadPos -= readLen;
            raf.seek(fileReadPos);
            raf.readFully(buf, 0, readLen);
            bufPos = readLen - 1;
        }
        // 识别UTF-8字符长度
        byte firstByte = buf[bufPos];
        int charLen = getUtf8CharLen(firstByte);
        // 遇到尾随字节持续向前查找首字节
        while (charLen == -1) {
            bufPos--;
            firstByte = buf[bufPos];
            charLen = getUtf8CharLen(firstByte);
        }
        // 截取完整字符的字节数组转码
        byte[] charBytes = new byte[charLen];
        int charStartPos = bufPos - charLen + 1;
        System.arraycopy(buf, charStartPos, charBytes, 0, charLen);
        bufPos = charStartPos - 1;
        return new String(charBytes, StandardCharsets.UTF_8).charAt(0);
    }

    private int getUtf8CharLen(byte b) {
        if ((b & 0x80) == 0) return 1;
        if ((b & 0xC0) == 0x80) return -1;
        if ((b & 0xE0) == 0xC0) return 2;
        if ((b & 0xF0) == 0xE0) return 3;
        if ((b & 0xF8) == 0xF0) return 4;
        throw new IllegalArgumentException("非法UTF-8字节: " + b);
    }

    public void close() throws IOException {
        raf.close();
    }
}

避坑说明 #

• 不要使用全量MappedByteBuffer映射：1G大小的内存映射会占用大量堆外内存，32位JVM还有映射大小限制，分块随机读完全规避这个问题，内存占用和文件总大小无关。
• 不需要改造FileInputStream的native方法：JDK原生输入流仅设计为正向顺序读取，修改底层native实现成本极高，RandomAccessFile提供的随机定位能力已经可以满足所有随机读需求。

内容的提问来源于stack exchange，提问作者JumperBot_