blocks|key|1478140|text|我猜FileInputStream可以让你以字节为单位读取数据。因此，使用FileInputStream打开文件并读取sizeof(标题)。我假设头部有固定的格式和大小。我在最初的帖子中没有提到这一点，但假设是这种情况，因为如果头部有可选的参数和不同的大小，它将变得更加复杂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478141|一旦你有了信息，就可以有一个头类，你可以在其中分配你已经读过的buffer的内容。然后以类似的方式解析记录。|1478142|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I guess FileInputStream lets you read in bytes. So, opening the file with FileInputStream and read in the sizeof(header). I am assuming that the header has a fixed format and size. I don't see that mentioned in the initial post, but assuming that is the case as it would get much more complex if the header has optional args and different sizes.

Once you have the info, there can be a header class in which you assign the contents of the buffer that you've already read. And then parse the records in a similar fashion.

blocks|key|1478182|text|您可以按如下方式使用DataInputStream类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478183|DataInputStream+in+=+new+DataInputStream(new+BufferedInputStream(
+++++++++++++++++++++++++new+FileInputStream("filename")));
int+x+=+in.readInt();
double+y+=+in.readDouble();

etc.|code-block|syntax|javascript|1478184|一旦你得到了这些值，你就可以随心所欲地处理它们。查看API中的java.io.DataInputStream类以获取更多信息。|1478185|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You could use the DataInputStream class as follows:

<pre><code>DataInputStream in = new DataInputStream(new BufferedInputStream(
 new FileInputStream("filename")));
int x = in.readInt();
double y = in.readDouble();

etc.
</code></pre>

Once you get these values you can do with them as you please. Look up the java.io.DataInputStream class in the API for more info.

blocks|key|1478238|text|在过去，我使用DataInputStream以指定的顺序读取任意类型的数据。这将不允许您轻松地解决大端/小端问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478239|在1.4版本中，java.nio.Buffer家族可能是不错的选择，但看起来你的代码可能会更复杂。这些类确实支持处理字节顺序问题。|1478240|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In the past I used DataInputStream to read data of arbitrary types in a specified order. This will not allow you to easily account for big-endian/little-endian issues.

As of 1.4 the java.nio.Buffer family might be the way to go, but it seems that the your code might actually be more complicated. These classes do have support for handling endian issues.

blocks|key|1478286|text|据我所知，Java强制您以字节的形式读取文件，而不是能够进行块读取。如果是序列化Java对象，情况就不同了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478287|显示的其他示例使用带有文件的DataInputStream类，但您也可以使用快捷方式：RandomAccessFile类：|offset|length|1478288|RandomAccessFile+in+=+new+RandomAccessFile("filename",+"r");
int+version+=+in.readInt();
byte+type+=+in.readByte();
int+beginOfData+=+in.readInt();
byte[]+tempId;
in.read(tempId,+0,+16);
String+id+=+new+String(tempId);|code-block|syntax|javascript|1478289|请注意，您可以将响应对象转换为一个类，如果这样做会更容易的话。|1478290|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/io/DataInputStream.html|1|http://java.sun.com/javase/6/docs/api/java/io/RandomAccessFile.html^0|0|E|F|0|17|G|1|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]|$D|11|E|12|1|13]]|A|$]]|$1|F|3|G|5|H|7|14|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]]]

To my knowledge, Java forces you to read a file as bytes rather than being able to block read. If you were serializing Java objects, it'd be a different story.

The other examples shown use the <a href="http://java.sun.com/javase/6/docs/api/java/io/DataInputStream.html" rel="noreferrer">DataInputStream</a> class with a File, but you can also use a shortcut: The <a href="http://java.sun.com/javase/6/docs/api/java/io/RandomAccessFile.html" rel="noreferrer">RandomAccessFile</a> class:

<pre><code>RandomAccessFile in = new RandomAccessFile("filename", "r");
int version = in.readInt();
byte type = in.readByte();
int beginOfData = in.readInt();
byte[] tempId;
in.read(tempId, 0, 16);
String id = new String(tempId);
</code></pre>

Note that you could turn the responce objects into a class, if that would make it easier.

blocks|key|1478350|text|不久前，我发现this+article使用反射和解析来读取二进制数据。在本例中，作者使用反射来读取java二进制.class文件。但是，如果您正在将数据读取到类文件中，它可能会有一些帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1478351|entityMap|0|LINK|mutability|MUTABLE|url|http://www.webservicessummit.com/Articles/MadhuOct2005_1.htm^0|7|C|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

A while ago I found <a href="http://www.webservicessummit.com/Articles/MadhuOct2005_1.htm" rel="nofollow noreferrer">this article</a> on using reflection and parsing to read binary data. In this case, the author is using reflection to read the java binary .class files. But if you are reading the data into a class file, it may be of some help.

blocks|key|1693779|text|我可能误解了你，但在我看来，你正在创建内存中的结构，你希望它是你想要从硬盘读取的内容的逐字节精确表示，然后将整个内容复制到内存中并在那里进行操作？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693780|如果真是这样，那你就是在玩一个非常危险的游戏。至少在C中，该标准不会强制诸如填充或对齐结构成员之类的事情。更不用说像大/小字节序或奇偶校验位之类的东西了……因此，即使你的代码碰巧运行，它也是非常不可移植和有风险的-你依赖于编译器的创建者在未来的版本中不会改变主意。|1693781|最好创建一个自动机来验证从HD读取的结构(逐字节)是否有效，并在确实正常的情况下填充内存结构。虽然您获得了平台和编译器的独立性，但您可能会少花几毫秒(并不像现代OSes那样做大量的磁盘读缓存)。此外，您的代码将很容易移植到另一种语言。|1693782|帖子编辑:在某种程度上，我很同情你。在DOS/Win3.11的好日子里，我曾经编写过一个C程序来读取BMP文件。并使用了完全相同的技术。一切都很好，直到我尝试为Windows编译它-哦！Int现在是32位长，而不是16位！当我尝试在Linux上编译时，我发现gcc的位域分配规则与Microsoft+C+(6.0!)非常不同。我不得不使用宏观技巧来使其便携。|1693783|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I may have misunderstood you, but it seems to me you're creating in-memory structures you hope will be a byte-per-byte accurate representation of what you want to read from hard-disk, then copy the whole stuff onto memory and manipulate thence?

If that's indeed the case, you're playing a very dangerous game. At least in C, the standard doesn't enforce things like padding or aligning of members of a struct. Not to mention things like big/small endianness or parity bits... So even if your code happens to run it's very non-portable and risky - you depend on the compiler's creator not changing its mind on future versions.

Better to create an automaton to both validate the structure being read (byte per byte) from HD is valid, and filling an in-memory structure if it's indeed OK. You may loose some milliseconds (not so much as it may seem for modern OSes do a lot of disk read caching) though you gain platform and compiler independence. Plus, your code will be easily ported to another language.

Post Edit: In a way I sympathize with you. In the good-ol' days of DOS/Win3.11, I once created a C program to read BMP files. And used exactly the same technique. Everything was nice until I tried to compile it for Windows - oops!! Int was now 32 bits long, rather than 16! When I tried to compile on Linux, discovered gcc had very different rules for bit fields allocation than Microsoft C (6.0!). I had to resort to macro tricks to make it portable...

blocks|key|1693860|text|下面是使用ByteBuffer+(Java+NIO)读取字节的链接|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693861|http://exampledepot.com/egs/java.nio/ReadChannel.html|offset|length|1693862|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1H|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

Here is a link to read byte using a ByteBuffer (Java NIO)

<a href="http://exampledepot.com/egs/java.nio/ReadChannel.html" rel="nofollow noreferrer">http://exampledepot.com/egs/java.nio/ReadChannel.html</a>

blocks|key|1693962|text|正如其他人提到的，DataInputStream和Buffers可能是您在java中处理二进制数据所需要的低级API。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1693963|然而，你可能想要像Construct这样的东西(wiki+page也有很好的例子：http://en.wikipedia.org/wiki/Construct_(python_library)，但它是用在Java上的。|offset|length|1693964|我不知道目前有什么(Java版本)，但采用这种方法(在代码中声明性地指定结构)可能是正确的方法。在Java中使用合适的fluent+interface，它可能非常类似于领域特定语言。|1693965|编辑:稍微搜索一下就会发现：|1693966|http://javolution.org/api/javolution/io/Struct.html|1693967|这可能就是你要找的东西。我不知道它是否有效或有什么好处，但它看起来是一个明智的起点。|1693968|entityMap|0|LINK|mutability|MUTABLE|url|http://construct.wikispaces.com/|1|http://en.wikipedia.org/wiki/Construct_(python_library)))|2|http://en.wikipedia.org/wiki/Fluent_interface|3^0|0|9|9|0|15|1J|1|0|1N|G|2|0|0|0|1F|3|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]|$D|15|E|16|1|17]]|A|$]]|$1|F|3|G|5|6|7|18|8|@]|9|@$D|19|E|1A|1|1B]]|A|$]]|$1|H|3|I|5|6|7|1C|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1D|8|@]|9|@$D|1E|E|1F|1|1G]]|A|$]]|$1|L|3|M|5|6|7|1H|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]|V|$5|Q|R|S|A|$T|W]]|X|$5|Q|R|S|A|$T|Y]]|Z|$5|Q|R|S|A|$T|K]]]]

As other people mention DataInputStream and Buffers are probably the low-level API's you are after for dealing with binary data in java.

However you probably want something like <a href="http://construct.wikispaces.com/" rel="nofollow noreferrer">Construct</a> (wiki page has good examples too: <a href="http://en.wikipedia.org/wiki/Construct_(python_library))" rel="nofollow noreferrer">http://en.wikipedia.org/wiki/Construct_(python_library)</a>, but for Java.

I don't know of any (Java versions) off hand, but taking that approach (declaratively specifying the struct in code) would probably be the right way to go. With a suitable <a href="http://en.wikipedia.org/wiki/Fluent_interface" rel="nofollow noreferrer">fluent interface</a> in Java it would probably be quite similar to a DSL.

EDIT: bit of googling reveals this:

<a href="http://javolution.org/api/javolution/io/Struct.html" rel="nofollow noreferrer">http://javolution.org/api/javolution/io/Struct.html</a>

Which might be the kind of thing you are looking for. I have no idea whether it works or is any good, but it looks like a sensible place to start.

blocks|key|1478714|text|我已经在java中写了一种技术来做这类事情-类似于读取位字段的古老的类似C的习惯用法。注意:这只是一个开始，但可以在此基础上进行扩展。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478715|here|offset|length|1478716|entityMap|0|LINK|mutability|MUTABLE|url|http://codify.flansite.com/2009/05/c-struct-like-parsing-of-binary-data-with-java/^0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

I've written up a technique to do this sort of thing in java - similar to the old C-like idiom of reading bit-fields. Note it is just a start but could be expanded upon.

<a href="http://codify.flansite.com/2009/05/c-struct-like-parsing-of-binary-data-with-java/" rel="nofollow noreferrer">here</a>

blocks|key|1694083|text|如果您使用的是Preon，那么您所要做的就是：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1694084|public+class+Header+{
++++@BoundNumber+int+version;
++++@BoundNumber+byte+type;
++++@BoundNumber+int+beginOfData;
++++@BoundString(size="15")+String+id;
}|code-block|syntax|javascript|1694085|一旦有了这些，您就可以使用一行代码来创建Codec：|1694086|Codec<Header>+codec+=+Codecs.create(Header.class);|1694087|您可以像这样使用编解码器：|1694088|Header+header+=+Codecs.decode(codec,+file);|1694089|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/preon/preon^0|7|5|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

If you would be using <a href="https://github.com/preon/preon" rel="noreferrer">Preon</a>, then all you would have to do is this:

<pre><code>public class Header {
 @BoundNumber int version;
 @BoundNumber byte type;
 @BoundNumber int beginOfData;
 @BoundString(size="15") String id;
}
</code></pre>

Once you have this, you create Codec using a single line:

<pre><code>Codec&lt;Header&gt; codec = Codecs.create(Header.class);
</code></pre>

And you use the Codec like this:

<pre><code>Header header = Codecs.decode(codec, file);
</code></pre>

blocks|key|1478816|text|我将创建一个包装数据的ByteBuffer表示形式的对象，并提供可直接从缓冲区读取的getter。通过这种方式，可以避免将数据从缓冲区复制到基元类型。此外，您可以使用MappedByteBuffer来获取字节缓冲区。如果您的二进制数据很复杂，您可以使用类对其进行建模，并为每个类提供缓冲区的切片版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1478817|class+SomeHeader+{
++++private+final+ByteBuffer+buf;
++++SomeHeader(+ByteBuffer+fileBuffer){
+++++++//+you+may+need+to+set+limits+accordingly+before
+++++++//+fileBuffer.limit(...)
+++++++this.buf+=+fileBuffer.slice();
+++++++//+you+may+need+to+skip+the+sliced+region
+++++++//+fileBuffer.position(endPos)
++++}
++++public+short+getVersion(){
++++++++return+buf.getShort(POSITION_OF_VERSION_IN_BUFFER);
++++}
}|code-block|syntax|javascript|1478818|字节缓冲区中的methods+for+reading+unsigned+values也很有用。|1478819|HTH|1478820|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/api/java/nio/ByteBuffer.html|1|http://java.sun.com/j2se/1.5.0/docs/api/java/nio/MappedByteBuffer.html|2|http://www.javafaq.nu/java-example-code-342.html^0|B|A|0|2B|G|1|0|0|7|Z|2|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]]]

I would create an object that wraps around a <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/ByteBuffer.html" rel="nofollow noreferrer">ByteBuffer</a> representation of the data and provide getters to read directly from the buffer. In this way, you avoid copying data from the buffer to primitive types. Furthermore, you could use a <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/MappedByteBuffer.html" rel="nofollow noreferrer">MappedByteBuffer</a> to get the byte buffer. If your binary data is complex, you can model it using classes and give each class a sliced version of your buffer.

<pre><code>class SomeHeader {
 private final ByteBuffer buf;
 SomeHeader( ByteBuffer fileBuffer){
 // you may need to set limits accordingly before
 // fileBuffer.limit(...)
 this.buf = fileBuffer.slice();
 // you may need to skip the sliced region
 // fileBuffer.position(endPos)
 }
 public short getVersion(){
 return buf.getShort(POSITION_OF_VERSION_IN_BUFFER);
 }
}
</code></pre>

Also useful are the <a href="http://www.javafaq.nu/java-example-code-342.html" rel="nofollow noreferrer">methods for reading unsigned values</a> from byte buffers.

HTH

blocks|key|1478857|text|我使用Javolution和javastruct，两者都处理字节和对象之间的转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478858|Javolution提供了表示C类型的类。您所需要做的就是编写一个描述C结构的类。例如，从C头文件中，|offset|length|1478859|struct+Date+{
++++unsigned+short+year;
++++unsigned+byte+month;
++++unsigned+byte+day;
};|code-block|syntax|javascript|1478860|应翻译为：|1478861|public+static+class+Date+extends+Struct+{
++++public+final+Unsigned16+year+=+new+Unsigned16();
++++public+final+Unsigned8+month+=+new+Unsigned8();
++++public+final+Unsigned8+day+++=+new+Unsigned8();
}|1478862|然后调用setByteBuffer初始化对象：|style|CODE|1478863|Date+date+=+new+Date();
date.setByteBuffer(ByteBuffer.wrap(bytes),+0);|1478864|javastruct使用注释来定义C结构中的字段。|1478865|@StructClass
public+class+Foo{

++++@StructField(order+=+0)
++++public+byte+b;

++++@StructField(order+=+1)
++++public+int+i;
}|1478866|初始化对象的步骤：|1478867|Foo+f2+=+new+Foo();
JavaStruct.unpack(f2,+b);|1478868|entityMap|0|LINK|mutability|MUTABLE|url|http://javolution.org/target/site/apidocs/javolution/io/Struct.html|1|http://code.google.com/p/javastruct/wiki/HowToUseJavaStruct^0|0|0|A|0|0|0|0|0|4|D|0|0|0|A|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@$D|1E|E|1F|1|1G]]|A|$]]|$1|F|3|G|5|H|7|1H|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1I|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1J|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1K|8|@$D|1L|E|1M|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|H|7|1N|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1O|8|@]|9|@$D|1P|E|1Q|1|1R]]|A|$]]|$1|W|3|X|5|H|7|1S|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1T|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|1U|8|@]|9|@]|A|$I|J]]|$1|12|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]|1A|$5|15|16|17|A|$18|1B]]]]

I used Javolution and javastruct, both handles the conversion between bytes and objects.

<a href="http://javolution.org/target/site/apidocs/javolution/io/Struct.html" rel="noreferrer">Javolution</a> provides classes that represent C types. All you need to do is to write a class that describes the C structure. For example, from the C header file,

<pre><code>struct Date {
 unsigned short year;
 unsigned byte month;
 unsigned byte day;
};
</code></pre>

should be translated into:

<pre><code>public static class Date extends Struct {
 public final Unsigned16 year = new Unsigned16();
 public final Unsigned8 month = new Unsigned8();
 public final Unsigned8 day = new Unsigned8();
}
</code></pre>

Then call <code>setByteBuffer</code> to initialize the object:

<pre><code>Date date = new Date();
date.setByteBuffer(ByteBuffer.wrap(bytes), 0);
</code></pre>

<a href="http://code.google.com/p/javastruct/wiki/HowToUseJavaStruct" rel="noreferrer">javastruct</a> uses annotation to define fields in a C structure.

<pre><code>@StructClass
public class Foo{

 @StructField(order = 0)
 public byte b;

 @StructField(order = 1)
 public int i;
}
</code></pre>

To initialize an object:

<pre><code>Foo f2 = new Foo();
JavaStruct.unpack(f2, b);
</code></pre>

I have to read a binary file in a legacy format with Java. 

In a nutshell the file has a header consisting of several integers, bytes and fixed-length char arrays, followed by a list of records which also consist of integers and chars.

In any other language I would create <code>struct</code>s (C/C++) or <code>record</code>s (Pascal/Delphi) which are byte-by-byte representations of the header and the record. Then I'd read <code>sizeof(header)</code> bytes into a header variable and do the same for the records.

Something like this: (Delphi)

<pre><code>type
 THeader = record
 Version: Integer;
 Type: Byte;
 BeginOfData: Integer;
 ID: array[0..15] of Char;
 end;

...

procedure ReadData(S: TStream);
var
 Header: THeader;
begin
 S.ReadBuffer(Header, SizeOf(THeader));
 ...
end;
</code></pre>

What is the best way to do something similar with Java? Do I have to read every single value on its own or is there any other way to do this kind of "block-read"?

Best way to read structured binary files with Java

编译器

Windows

Linux

Java

我必须用Java读取传统格式的二进制文件。简而言之，该文件有一个由几个整数、字节和固定长度的字符数组组成的头部，后面是一个记录列表，该列表也由整数和字符组成。在任何其他语言中，我都会创建struct (C/C++)或record (Pascal/Delphi)，它们是报头和记录的逐字节表示。然后，我将sizeof(he...

问用Java读取结构化二进制文件的最佳方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用Java读取结构化二进制文件的最佳方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用Java读取结构化二进制文件的最佳方法
EN