如何在不耗尽内存的情况下反向读取文件？

Question

---

故事

---

我最近有问题...

我必须逐个字符地反向读取文件，而不会耗尽内存。

我无法逐行读取它并使用StringBuilder将其反转，因为它是一个占用一演出 (GB) 的 I/O 空间的单行文件。

因此它会占用太多 JVM（和系统）的内存。

我决定从头到尾（从头到尾）逐个字符地阅读它，这样我就可以在不消耗太多内存的情况下尽可能多地处理它。

---

我试过的

---

我知道如何一次性读取文件：

（ MappedByteBuffer + FileChannel + Charset这给了我OutOfMemoryException s）

并使用 UTF-8 字符支持逐字符读取文件

( FileInputStream + InputStreamReader )。

问题是FileInputStream的#read()只调用#read0()这是本机方法！

因此，我不知道底层代码......

这就是为什么我今天在这里（或至少在完成之前）！

Answer 1

这不支持多字节 UTF-8 字符

使用RandomAccessFile ，您可以轻松地从头到尾以块的形式读取文件，并反转每个块。

这是一个简单的例子：

import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.stream.IntStream;

class Test {
    private static final int BUF_SIZE = 10;
    private static final int FILE_LINE_COUNT = 105;

    public static void main(String[] args) throws Exception {
        // create a large file
        try (FileWriter fw = new FileWriter("largeFile.txt")) {
            IntStream.range(1, FILE_LINE_COUNT).mapToObj(Integer::toString).forEach(s -> {
                try {
                    fw.write(s + "\n");
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        }
        // reverse the file
        try (RandomAccessFile raf = new RandomAccessFile("largeFile.txt", "r")) {
            long size = raf.length();
            byte[] buf = new byte[BUF_SIZE];

            for (long i = size - BUF_SIZE; i > -BUF_SIZE; i -= BUF_SIZE) {
                long offset = Math.max(0, i);
                long readSize = Math.min(i + BUF_SIZE, BUF_SIZE);
                raf.seek(offset);
                raf.read(buf, 0, (int) readSize);
                for (int j = (int) readSize - 1; j >= 0; j--) {
                    System.out.print((char) buf[j]);
                }
            }
        }
    }
}

这使用了一个非常小的文件和非常小的块，以便您可以轻松地对其进行测试。 增加这些常数以查看它在更大范围内的工作。

输入文件包含换行符，以便于读取输出，但反转不依赖于文件“有行”。

Answer 2

这会做到的（但正如所写的那样，它不是很有效）。

• 只需跳到最后一个位置，读取少一个并读取并打印字符。
• 然后将位置重置为标记，调整大小并继续。

File f = new File("Some File name");
int size = (int) f.length();
int bsize = 1;
byte[] buf = new byte[bsize];
try (BufferedInputStream b =
        new BufferedInputStream(new FileInputStream(f))) {
    while (size > 0) {
        b.mark(size);
        b.skip(size - bsize);
        int k = b.read(buf);
        System.out.print((char) buf[0]);
        size -= k;
        b.reset();
    }
    
} catch (IOException ioe) {
    ioe.printStackTrace();
}

这可以通过增加缓冲区大小和对标记和跳过参数进行等效调整来改进。

更新后的版本

我对我的回答并不完全满意，所以我把它变得更笼统。 一些变量可以起到双重作用，但使用有意义的名称有助于阐明它们的使用方式。

• 必须使用Mark ，以便可以使用reset 。 但是，它只需要设置一次，并且在主循环之外设置为位置 0。 我不知道标记更接近读取点是否更有效。
• skipCnt - 最初设置为fileLength ，它是读取前要跳过的字节数。 如果剩余字节数大于缓冲区大小，则跳过计数将为skipCnt - bsize 。 否则它将是0 。
• remainingBytes字节 - 仍有多少字节要读取的运行总数。 它通过减去当前的readCnt来更新。
• readCnt - 要读取的字节数。 如果remainingBytes字节大于bsize则设置为bsize ，否则设置为remainingBytes字节

while 循环从接近末尾的位置开始连续读取文件，然后以相反的顺序打印刚刚读取的信息。 更新所有变量并重复该过程，直到remainingBytes字节数达到 0。

File f = new File("some file");
int bsize = 16;
int fileSize = (int)f.length();
int remainingBytes = fileSize;
int skipCnt = fileSize;
byte[] buf = new byte[bsize];
try (BufferedInputStream b =
        new BufferedInputStream(new FileInputStream(f))) {
    b.mark(0);
    while(remainingBytes > 0) {
        skipCnt = skipCnt > bsize ? skipCnt - bsize : 0;
        b.skip(skipCnt);
        int readCnt = remainingBytes > bsize ? bsize : remainingBytes; 
        b.read(buf,0,readCnt);
        for (int i = readCnt-1; i >= 0; i--) {
           System.out.print((char) buf[i]);
        }
        remainingBytes -= readCnt;
        b.reset();
    }
    
} catch (IOException ioe) {
    ioe.printStackTrace();
}