在Java中读取一个大文件并写入多个（数十个、数百个或数千个）文件？

我有一个很大的ish文件（4-5GB压缩），其中包含一些小消息，我希望按消息类型将其解析为大约6000个文件。消息很小；5到50字节之间的任意位置，具体取决于类型

每条消息都以一个固定大小的类型字段（一个6字节的键）开头。如果我读取类型为“000001”的消息，我想将其有效负载附加到000001.dat，等等。输入文件包含混合消息；我想要N个同质输出文件，其中每个输出文件只包含给定类型的消息

将这些消息写入这么多单独文件的有效快速方法是什么？我希望使用尽可能多的内存和处理能力来尽可能快地完成它。我可以将压缩或未压缩的文件写入磁盘

我正在考虑使用带有消息类型键和outputstream值的hashmap，但我相信有更好的方法

---

谢谢

您可能不需要哈希映射。你可以

读一条消息

以附加模式打开新文件

将消息写入新文件

关闭新文件

---

但是，不确定这是否会更快，因为您需要执行大量的打开和关闭操作。

我建议使用某种智能池：打开最大/最常用的文件以提高性能，关闭其余文件以节省资源

---

如果主文件主要由记录类型1-5组成，请根据需要随时打开这些文件。其他文件可以根据需要打开和关闭，这样您就不会耗尽系统的资源。

因为您要对许多文件执行许多小的写入操作，所以您希望尽量减少写入次数，特别是考虑到最简单的设计几乎可以保证每一次新写入都会涉及一个新文件的打开/关闭

相反，为什么不将每个键映射到缓冲区？最后，将每个缓冲区写入磁盘。或者，如果担心内存太多，可以将缓冲区的结构设置为每1K、5K或任何行写入一次。e、 g

public class HashLogger {

          private HashMap<String,MessageBuffer> logs;

          public void write(String messageKey, String message)
          {
              if (!logs.contains(messageKey)) { logs.put(messageKey, new MessageBuffer(messageKey); }
              logs.get(messageKey).write(message);
          }

         public void flush()
         {
             for (MessageBuffer buffer: logs.values())
             {
                buffer.flush();
             }
            // ...flush all the buffers when you're done...
         }

    private class MessageBuffer {
             private MessageBuffer(String name){ ... }
             void flush(){ .. something here to write to a file specified by name ... }
             void write(String message){
             //... something here to add to internal buffer, or StringBuilder, or whatever... 
             //... you could also have something here that flushes if the internal builder gets larger than N lines ...
     }
}

公共类哈希记录器{
私有HashMap日志；
公共无效写入（字符串消息键、字符串消息）
{
如果（！logs.contains（messageKey））{logs.put（messageKey，newmessagebuffer（messageKey）；}
logs.get（messageKey）、write（message）；
}
公共图书馆
{
for（MessageBuffer:logs.values（））
{
buffer.flush（）；
}
//…完成后刷新所有缓冲区。。。
}
私有类消息缓冲区{
私有消息缓冲区（字符串名称）{…}
void flush（）{..此处要写入名称指定的文件的内容…}
无效写入（字符串消息）{
//…这里有些东西要添加到内部缓冲区或StringBuilder，或其他。。。
//…如果内部生成器大于N行，您也可以在此处刷新某些内容。。。
}
}

---

您甚至可以创建单独的Log4j记录器，可以将其配置为使用缓冲日志记录，如果像slf4j这样的更现代的日志记录框架也不支持这一点，我会感到惊讶。

类似Unix的系统通常会限制在任何给定时间打开的文件句柄数量；例如，在我的Linux上，它当前为1024个呃，我可以在合理的范围内更改它。但是这些限制有很好的理由，因为打开的文件是系统的负担

您还没有回答我关于同一个键在您的输入中是否多次出现的问题，这意味着可能需要将多个不同批次的数据连接到每个文件中。如果不是这样的话，Pace的答案将是您能做的最好的答案，因为所有这些工作都需要完成，设置没有意义围绕这样一个简单的事件序列组建一个庞大的政府

但是，如果您输入的同一密钥中有多条消息，那么保持大量文件处于打开状态将是有效的。不过，我建议不要尝试同时保持所有6000个文件处于打开状态。相反，我会选择500个左右的文件，以先到先得的方式打开；即，您打开前500个（大约500个）的文件不同的消息键，然后仔细阅读整个输入文件，寻找要添加到这500个键中的内容，然后在输入时点击EOF将它们全部关闭。您还需要保留一个已处理的键的

HashSet

，因为您随后会继续重新读取输入文件，处理下一批未理解的500个键第一轮

理由：打开和关闭文件（通常）这是一项成本高昂的操作；如果您能提供帮助，您不希望在每个文件上多次打开和关闭数千个文件。因此，您可以保持尽可能多的句柄处于打开状态，所有这些句柄最终都会在一次输入中填充。另一方面，在一个输入文件中按顺序进行流式处理是非常有效的，即使您必须进行12次输入通过输入文件，与打开/关闭其他6000个文件所需的时间相比，这样做的时间几乎可以忽略不计

伪代码：

processedSet = [ ]
keysWaiting = true
MAXFILE = 500
handlesMap = [ ]
while (keysWaiting) {
  keysWaiting = false
  open/rewind input file
  while (not EOF(input file)) {
    read message
    if (handlesMap.containsKey(messageKey)) {
       write data to handlesMap.get(messageKey)
    } else if (processedSet.contains(messageKey) {
       continue // already processed
    } else if (handlesMap.size < MAXFILE) {
       handlesMap.put(messageKey, new FileOutputStream(messageKey + ".dat")
       processedSet.add(messageKey)
       write data to handlesMap.get(messageKey)
    else
       keysWaiting = true
    endif
  }
  for all handlesMap.values() {
     close file handle
  }
  handlesMap.clear
}

processedSet=[]
keysWaiting=true
MAXFILE=500
handlesMap=[]
正在（等待）{
keysWaiting=false
打开/回放输入文件
while（非EOF（输入文件））{
阅读信息
if（handlesMap.containsKey（messageKey））{
将数据写入handlesMap.get（messageKey）
}else if（processedSet.contains（messageKey）{
继续//已处理
}else if（handlesMap.sizepublic class MessageProcessor
{
    int _msgSize;                   // the number of bytes to read per message
    byte[] _buf = new byte[1024];   // bigger than I said, but it's only 6 Mb total
    int _curSize;                   // when this approaches _buf.length, write