1

好的，所以我有两种方法应该可以工作，据我所知，哪个会得到一个叫做 an 的东西ItemStack，然后序列化它。

  1. 然后将序列化输入 aByteOutputStream并转换为 a byte[]。byte[]然后将其转换为 a ，byte并在其间设置一个特殊的分隔符。
  2. 这些字节中的每一个（最初有一个ItemStack[]）都输入到 abyte[]中，并存储在 a 中byte[][][]。
  3. 稍后，我尝试通过调用另一个方法ItemStack[]从中检索 ，该byte[]方法使用特殊的字节分隔符集将 a 分隔byte[]为 abyte并将其转换为 a Map<String, Object>，然后转换为ItemStack。

这一切一定很令人困惑，就像对我一样，所以我将在下面发布我目前拥有的内容（仅两种方法）。如果需要更多，请告诉我，我很可能会得到它。

我的问题是这不起作用。没有错误或任何东西，但由于某种原因，数据并没有完全通过。如果有人对此有任何解决方案，请提供帮助。也许是因为我拆分数据的方式......或者我正在切断或添加字节到字符串或对象。

private static byte[] contentsToBytes(Block block, ItemStack[] contents) throws IOException {
    byte[] bytes = new byte[] {block.getData()};
    byte[] dataSplitter = ITEMSTACKDATASPLITTER.getBytes("UTF-8");
    for (int i = 0; i < contents.length; i++) {
        Map<String, Object> serialized = contents[i].serialize();
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(serialized);
        byte[] serializedByteArray = byteOut.toByteArray();
        byte[] copyBytes = Arrays.copyOf(bytes, bytes.length + dataSplitter.length + serializedByteArray.length);
        for (int j = 0; j < dataSplitter.length; j++) {
            copyBytes[bytes.length + j] = dataSplitter[j];
        }
        for (int k = 0; k < serializedByteArray.length; k++) {
            copyBytes[bytes.length + dataSplitter.length + k - 1] = serializedByteArray[k];
        }
        bytes = copyBytes;
    }
    return bytes;
}    

private static ItemStack[] bytesToContents(byte[] bytes) throws IOException, ClassNotFoundException {
    ArrayList<ItemStack> stacks = new ArrayList<ItemStack>();
    byte[] dataSplitter = ITEMSTACKDATASPLITTER.getBytes("UTF-8");
    byte[] currentByteItemStack = new byte[1];
    boolean decompress = false;
    for (int i = 1; i < bytes.length; i++) {
        byte current = bytes[i];
        if (current == dataSplitter[0]) {
            byte[] dataSplitterTest = Arrays.copyOfRange(bytes, i, i - 1 + dataSplitter.length);
            boolean match = true;
            for (int j = 0; j < dataSplitter.length; j++) {
                if (dataSplitter[j] != dataSplitterTest[j]) {
                    match = false;
                    break;
                }
            }
            if (decompress && match) {
                ByteArrayInputStream byteIn = new ByteArrayInputStream(Arrays.copyOfRange(currentByteItemStack, 0, currentByteItemStack.length - 2));
                ObjectInputStream in = new ObjectInputStream(byteIn);
                @SuppressWarnings("unchecked") Map<String, Object> serialized = (Map<String, Object>) in.readObject();
                stacks.add(ItemStack.deserialize(serialized));
            }
            i += dataSplitter.length - 1;
            decompress = match;
        }
        if (decompress) {
            currentByteItemStack = Arrays.copyOf(currentByteItemStack, currentByteItemStack.length + 1);
            currentByteItemStack[i - 1] = current;
        }
    }
    return stacks.toArray(new ItemStack[stacks.size()]);
}
4

1 回答 1

5

所以听起来你正在竭尽全力编写自己的序列化，但 java 已经内置了很好的序列化。

如果是因为您尝试序列化的这些对象没有实现可序列化，那么制作一个可以序列化的临时包装类，那么您可以使用默认的序列化。

例子

public class MyItemStack implements Externalizable{
    private static final long serialVersionUID = 1L;
    ItemStack itemStack;
    MyItemStack(ItemStack itemStack){
        this.itemStack = itemStack;
    }
    @Override
    public void readExternal(ObjectInput arg0) throws IOException, ClassNotFoundException {
        ...
    }

    @Override
    public void writeExternal(ObjectOutput arg0) throws IOException {
        ...
    }
}

现在你只需要重写这些方法来存储 ItemStack 或 Block 的真正含义（通常作为原语）

之后的序列化应该相当简单，就像这样。

FileOutputStream fos = new FileOutputStream("myfile");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(myHashMap);
oos.close();

FileInputStream fis = new FileInputStream("myfile");
ObjectInputStream ois = new ObjectInputStream(fis);
Map<String,MyItemStack> myMap = (Map<String,MyItemStack>) ois.readObject();
ois.close();
于 2013-05-13T03:18:47.130 回答