我们如何知道一条记录是否已经被读取？我们如何跟踪记录指针？

Question

我对与处理文件相关的算法感到困惑。
根据我的在线研究，表示可变长度记录的标准方法是将元数据放在数据中，例如记录的长度。此外，如果我们想按某种顺序保存记录，我们还可以将指向下一条记录的指针存储为记录字段的一部分。
让我们以一个文件为例，其中我们有<length,data,next_record_ptr> 形式的记录，这与我上面描述的一致。
我看到的代码 sn-ps 通常会在内存缓冲区中读取文件的一部分，我猜这很有意义。示例：

ByteBuffer copy = ByteBuffer.allocate(SIZE);  
FileChannel fc = FileChannel.open(file, READ, WRITE);  
int nread;  
do {  
   nread = fc.read(copy);  
} while (nread != -1 && copy.hasRemaining());  

我认为这或多或少是一种读取内存中文件部分的方法。 SIZE 的大小可以包含我们的多个记录。

问题：当我们在内存中有 X 条记录时，我们如何知道我们要读取的特定记录是否在我们的缓冲区中？示例：如果我有指向下一条记录的指针，我如何知道该特定记录已作为缓冲区的一部分加载，或者我必须从文件中读取更多数据？
这部分在教科书中被提到很简单，但我对这实际上是如何实现的感到困惑。

明确一点：用 Java 提供示例代码真的很棒！！！但是用伪代码或清晰的算法对我来说清楚地解释这个黑点也很棒！

更新：
为了更清楚：
如果我已经读取了数组 [N] 中的 N 条记录。如果我阅读记录 array[0] 然后得到 array[0].pointerToNext 这是例如0x123A 在文件中。我怎么知道：
1) 如果位置0x123A中的记录已在缓冲区中读取，即array[n]
2) 这条记录在缓冲区中的索引是多少？

Answer 1

在文件中，记录指针通常存储为记录索引或文件位置。因此，您可以根据您在文件中的当前位置推断您是否已经阅读了特定记录。

在您的示例中，您可以使用变量 pos 来跟踪文件位置：

int pos = 0;
int nread;  
do {  
   nread = fc.read(copy);
   if(nread == -1) {
      break;
   } else {
      pos += nread;
   }
} while (copy.hasRemaining());  

Answer 2

您需要随时读取数据，并将其纳入您的读取中。这是解决这个问题的一种方法，也许我会这样做。

// read a made up database
// untested

public class SimpleDatabaseRead {

    public void main(String[] args) {
        if (args == null || args.length == 0) {
            System.out.println("no file");
            return;
        }

        try {
            File file = new File(args[0]);
            FileInputStream in = null;

            try {
                in = new FileInputStream(file);

                // rec length will be 16-bit unsigned
                // large array OK, only 64KiB in mem
                byte[] bytes = new byte[65536];

                int bread = 0;
                long fpos = 0, next = 0;

                char[][] rec;

                while ((bread = in.read(bytes, 0, 4)) != -1) {
                    fpos += bread;

                    // length of this rec in bytes
                    int len = ((bytes[0] & 0xFF) << 8) | (bytes[1] & 0xFF);

                    // num entries in rec, for convenience
                    int entries = ((bytes[2] & 0xFF) << 8) | (bytes[3] & 0xFF);

                    if (in.read(bytes, 0, len) != len)
                        break;
                    fpos += len;

                    rec = new char[entries][];

                    for (int i = 0, k = 0, h; i < entries; i++) {
                        rec[i] = new char[
                            ((bytes[k++] & 0xFF) << 8) | (bytes[k++] & 0xFF)];

                        for (h = 0; h < rec[i].length && k < len; h++)
                            rec[i][h] = ((bytes[k++] & 0xFF) << 8) | (bytes[k++] & 0xFF);
                    }

                    for (char[] rec : recs)
                        System.out.println("record: " + new String(rec));

                    if (in.read(bytes, 0, 4) != len)
                        break;
                    fpos += bread;

                    // 48-bit file marker of next rec
                    next = ((bytes[0] & 0xFF) << 32)
                         | ((bytes[1] & 0xFF) << 24)
                         | ((bytes[2] & 0xFF) << 24)
                         |  (bytes[3] & 0xFF);

                    if (next < fpos) {
                        in.close();
                        in = new FileInputStream(file);
                        in.skip(fpos = next);
                    }
                }

            } finally {
                if (in != null) in.close();
            }
            System.out.println("read ended");

        } catch (IOException e) {
            System.out.println(e.getMessage());
        } catch (FileNotFoundsException e) {
            System.out.println(e.getMessage());
        }
    }
}

据我所知，在 Java 中并没有真正的好方法来寻求。 Seeking a ByteArrayInputStream using java.io 有一些想法，但要点是基本上你要么：

• 如示例中所示创建一个新的 InputStream 或
• 使用据称通常较慢的 RandomAccessFile（自行测试）。

换句话说，您最好使用可以顺序读取的数据。

我猜不是像您建议的那样以另一种方式逐块读取，而是将缓冲区大小设置为任意长度并随时制定记录。要判断下一个点是否在“缓冲区中”，您将读取指针并基本上使用条件pointer < fpos + buffer.length。我不认为我会推荐这种方法，因为缓冲区可能小于记录的长度。在这种情况下，您最终会在新数组中制定记录，因此您不妨阅读整个内容。除非它们非常非常大，并且您必须部分阅读这些块。