格式错误的HashMap二进制序列化<string，double> </string，double>

Question

我编写了一些代码来序列化HashMap<String,Double>，通过迭代条目并序列化每个条目而不是使用ObjectOutputStream.readObject()。原因只是效率：结果文件要小得多，写入和读取速度要快得多（例如，0.6秒内为23 MB，9.9秒内为29 MB）。

这就是我所做的序列化：

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test.bin"));
oos.writeInt(map.size()); // write size of the map
for (Map.Entry<String, Double> entry : map.entrySet()) { // iterate entries
    System.out.println("writing ("+ entry.getKey() +","+ entry.getValue() +")");
    byte[] bytes = entry.getKey().getBytes();
    oos.writeInt(bytes.length); // length of key string
    oos.write(bytes); // key string bytes
    oos.writeDouble(entry.getValue()); // value
}
oos.close();

如您所见，我为每个键byte获取String数组，序列化其长度，然后是数组本身。这就是我反序列化所做的：

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.bin"));
int size = ois.readInt(); // read size of the map
HashMap<String, Double> newMap = new HashMap<>(size);
for (int i = 0; i < size; i++) { // iterate entries
    int length = ois.readInt(); // length of key string
    byte[] bytes = new byte[length];
    ois.read(bytes); // key string bytes
    String key = new String(bytes);
    double value = ois.readDouble(); // value
    newMap.put(key, value);
    System.out.println("read ("+ key +","+ value +")");
}

问题是在某些时候密钥没有正确序列化。我一直在调试，我可以看到ois.read(bytes)读取8个字节而不是16个字节，因此密钥String没有正确形成，double使用未读取的密钥的最后8个字节读取值。最后，无处不在。

使用下面的示例数据，输出在某些时候将是这样的：

read (2010-00-056.html,12154.250518054876)
read (2010-00-        ,1.4007397428546247E-76)
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at ti.Test.main(Test.java:82)

问题可以在序列化文件中找到（它应该是2010-00-008.html）：

在String密钥之间添加了两个字节。有关详细信息，请参阅MxyL's answer。所以这一切归结为：为什么要添加这两个字节，为什么readFully能正常工作？

为什么String正确（de）序列化？可能是某种固定块大小的填充或类似的东西？ 在寻找效率时，是否有更好的方法可以手动序列化String？我期待某种writeString和readString，但似乎没有Java中的事ObjectStream。

我一直在尝试使用缓冲流，以防万一有问题，明确说明使用不同的编码写入和读取多少字节，但没有运气。

这是一些重现问题的示例数据：

HashMap<String, Double> map = new HashMap<String, Double>();
map.put("2010-00-027.html",21732.994621513037); map.put("2010-00-020.html",3466.5169348296736); map.put("2010-00-051.html",12528.648992702407); map.put("2010-00-062.html",3354.8950010256385);
map.put("2010-00-024.html",10295.095511718278); map.put("2010-00-052.html",5381.513344679818);  map.put("2010-00-007.html",16466.33813960735);  map.put("2010-00-017.html",9484.969198176652);
map.put("2010-00-054.html",15423.873112634772); map.put("2010-00-022.html",8123.842752870753);  map.put("2010-00-033.html",21238.496665104063); map.put("2010-00-028.html",7578.792651786424);
map.put("2010-00-048.html",3566.4118233046393); map.put("2010-00-040.html",2681.0799941861724); map.put("2010-00-049.html",14308.090890746222); map.put("2010-00-058.html",5911.342406606804);
map.put("2010-00-045.html",2284.118716145881);  map.put("2010-00-031.html",2859.565771680721);  map.put("2010-00-046.html",4555.187022907964);  map.put("2010-00-036.html",8479.709295569426);
map.put("2010-00-061.html",846.8292195815125);  map.put("2010-00-023.html",14108.644025417952); map.put("2010-00-041.html",22686.232732684934); map.put("2010-00-025.html",9513.539663409734);
map.put("2010-00-012.html",459.6427911376829);  map.put("2010-00-005.html",0.0);    map.put("2010-00-013.html",2646.403220496738);  map.put("2010-00-065.html",5808.86423609936);
map.put("2010-00-056.html",12154.250518054876); map.put("2010-00-008.html",10811.15198506469);  map.put("2010-00-042.html",9271.006516004005);  map.put("2010-00-000.html",4387.4162586468965);
map.put("2010-00-059.html",4456.211623469774);  map.put("2010-00-055.html",3534.7511584735325); map.put("2010-00-057.html",8745.640098512009);  map.put("2010-00-032.html",4993.295735075575);
map.put("2010-00-021.html",3852.5805998017922); map.put("2010-00-043.html",4108.020033536286);  map.put("2010-00-053.html",2.2446400279239946); map.put("2010-00-030.html",17853.541210836203);

Answer 1

ois.read(bytes); // key string bytes

将其更改为使用readFully（）。你假设读取填充缓冲区。它没有义务传输多个字节。

  

在寻找效率时，是否有更好的方法手动序列化String？

有writeUTF（）和readUTF（）对。

您应该注意，通过调用getBytes（），您将引入平台依赖项。您应该在此处以及在重构String时指定字符集。

Answer 2

这里有两件值得关注的事情

首先，如果您取出样本数据中的最后4个条目，则不会发生错误。也就是说，不会错误地添加两个字节。怪异。

其次，如果您在十六进制编辑器中打开文件，并向下滚动到出现两个额外字节的条目，您将看到它以一个4字节整数开头，正确值为16（保持在介意这是大端）。然后你会看到你的字符串带有两个额外的字节，然后是与之相关的双字符。

现在，奇怪的是Java如何读取这些字节。首先，它按照您的指示读取字符串的长度。然后它尝试读取16个字节......但是在这里它似乎无法读取16个字节，因为你的打印语句显示

read (2010-00-,1.3980409401811577E-76))

现在将光标放在这两个奇怪的字节之后，你会看到这个

从字符串开始的位置到指针当前所在的位置，它似乎只读取了10个字节。

此外，当我尝试从IDE的控制台复制该行时，它只粘贴

read (2010-00-

通常当我的复制粘贴中的字符串突然结束时，我通常会怀疑是空字节。实际上，看着我的剪贴板，看起来字节没有被完全读入缓冲区：

好的，所以看起来Java只能设法读取10个字节并继续前进，这解释了字符串和之后的数字。

因此，当您read并传入缓冲区时，它似乎没有被完全填充。甚至工具提示本身的建议告诉我使用readFully！

所以做了一些测试，我继续改变

ois.read(bytes); // key string bytes

到

ois.readFully(bytes, 0, length); // key string bytes

无论出于何种原因，这都有效。

read (2010-00-013.html,2646.403220496738)
read (2010-00-005.html,0.0)
read (2010-00-056.html,12154.250518054876)
read (2010-00-008.html,10811.15198506469)
read (2010-00-042.html,9271.006516004005)
read (2010-00-000.html,4387.4162586468965)  // where it was failing before
read (2010-00-059.html,4456.211623469774)

问题

现在，它确实有效的事实是一个问题。 为什么有效吗？很明显，你的字符串之间有两个额外的字节（导致它的长度为18，而不是16）。它不像文件已经改变或任何东西。

事实上，当我手动编辑文件以便它只有三个条目时，我指出只有两个条目，这就是我得到的输出：

read (2010-00-056.html,12154.250518054876)
read (2010-00-wd008.ht,1.2466701288348126E219)

这是我对18字节字符串的期望（好吧，可能不是wd，我期望w,），但你指定只有16字节。你应该同意这个事实使用readFully实际工作的很奇怪。

所以有几个谜团

1. 为什么要添加这两个额外字节
2. 删除最后4个条目时，为什么不添加它们（如果需要，可以添加更多条目）
3. 为什么使用readFully工作，其他一切都不变？

不幸的是，这个答案并没有回答你的问题，我现在也很难过，不仅是你提出的问题，还有我所看到的行为。

Answer 3

ObjectOutputStream首先写入STREAM_MAGIC（0xaced）然后写入STREAM_VERSION（5）然后写入TC_BLOCKDATALONG（0x7A）然后写入块大小（1024），对于最后一个块，如果长度小于255，则表示TC_BLOCKDATA（0x77）和块大小（最后一个块的长度）

所以当ObjectOutputStream使用readFully时，它首先将数据读取到跳过STREAM_MAGIC，STREAM_VERSION的缓冲区，然后对于每个块，读取块大小以获取大小然后读取所有大小数据到缓冲区

Answer 4

ObjectInputStream#read不保证它会读取buffer.length（）字节数。当读取发生在当前预读缓冲区块的边缘时，它将仅返回缓冲区中剩余的字节数。应该这样写。

        int offset=0;
        while(offset<length) {
            int cnt=ois.read(bytes,offset, length-offset); // key string bytes
            offset+=cnt;
        }