How to read a binaryfile into an object

Question

Hello,
I want to read a binary file into an object. In this object, we have
several variables which need to be filled. I did the following thing:
---Start code---
import java.io.*;
import java.lang.reflect.*;
public class BinaryFile {
  private File file;
  private DataInputStream dis;
  public BinaryFile() {}
  // Open the file
public void openFile(String file) throws FileNotFoundException {
    this.file = new File(file);
    if (! this.file.exists())
      throw new FileNotFoundException();
    dis = new DataInputStream(new FileInputStream(this.file));
  // Close the file
  public void closeFile() throws IOException {
    dis.close();
public void readObject(int offset, Object o) throws EndOfFileException,
                       IOException {
    // Get the fields in the object
    Field[] fields = o.getClass().getFields();
    try {
      String type, naam;
      Class className;
      int lengte, arrayLengte;
      boolean isArray;
      for (int i = 0; i !< fields.length; i++) {
        naam = fields.getName(); // Get the name of the field
className = fields[i].getType(); // Get the type
type = className.getName(); // Get the name of the type
isArray = className.isArray(); // Is it an array?
arrayLengte = 1;
fields[i].setAccessible(true); // For setting the values
if (isArray) {                      // If it is an array,
type = getType(type); // decode it
// Get the size of the array
arrayLengte = Array.getLength(fields[i].get(o));
// Determine the type of the variable and fill it.
// Char
if (type.equalsIgnoreCase("char")) {
lengte = 1;
if (isArray)
fields[i].set(o, readChars(arrayLengte * lengte));
else
fields[i].setChar(o, readChar());
// Byte
} else if (type.equalsIgnoreCase("byte")) {
lengte = 1;
if (isArray)
fields[i].set(o, readBytes(arrayLengte * lengte));
else
fields[i].setByte(o, readByte());
// Short
} else if (type.equalsIgnoreCase("short")) {
lengte = 2;
if (isArray)
fields[i].set(o, readShorts(arrayLengte * lengte));
else
fields[i].setShort(o, readShort());
// Int
} else if (type.equalsIgnoreCase("int")) {
lengte = 4;
if (isArray)
fields[i].set(o, readInts(arrayLengte * lengte));
else
fields[i].setInt(o, readInt());
// Float
} else if (type.equalsIgnoreCase("float")) {
lengte = 4;
if (isArray)
fields[i].set(o, readFloats(arrayLengte * lengte));
else
fields[i].setFloat(o, readFloat());
// Long
} else if (type.equalsIgnoreCase("long")) {
lengte = 8;
if (isArray)
fields[i].set(o, readLongs(arrayLengte * lengte));
else
fields[i].setLong(o, readLong());
// Double
} else if (type.equalsIgnoreCase("double")) {
lengte = 8;
if (isArray)
fields[i].set(o, readDoubles(arrayLengte * lengte));
else
fields[i].setDouble(o, readDouble());
catch (IOException ioex) {
throw ioex;
catch (Exception ex) {
ex.printStackTrace();
// Methods for reading from the DataInputStream
private char[] readChars(int lengte) throws IOException {
char[] c = new char[lengte];
for (int i = 0; i < c.length; i++)
c[i] = dis.readChar();
return c;
private char readChar() throws IOException {
return dis.readChar();
private byte[] readBytes(int lengte) throws IOException {
byte[] b = new byte[lengte];
for (int i = 0; i < b.length; i++)
b[i] = dis.readByte();
return b;
private byte readByte() throws IOException {
return dis.readByte();
private short[] readShorts(int lengte) throws IOException {
short[] s = new short[lengte];
for (int i = 0; i < s.length; i++)
s[i] = dis.readShort();
return s;
private short readShort() throws IOException {
return dis.readShort();
private int[] readInts(int lengte) throws IOException {
int[] i = new int[lengte];
for (int j = 0; j < i.length; j++)
i[j] = dis.readInt();
return i;
private int readInt() throws IOException {
return dis.readInt();
private double[] readDoubles(int lengte) throws IOException {
double[] d = new double[lengte];
for (int i = 0; i < d.length; i++)
d[i] = dis.readDouble();
return d;
private double readDouble() throws IOException {
return dis.readDouble();
private float[] readFloats(int lengte) throws IOException {
float[] f = new float[lengte];
for (int i = 0; i < f.length; i++)
f[i] = dis.readFloat();
return f;
private float readFloat() throws IOException {
return dis.readFloat();
private long[] readLongs(int lengte) throws IOException {
long[] l = new long[lengte];
for (int i = 0; i < l.length; i++)
l[i] = dis.readLong();
return l;
private long readLong() throws IOException {
return dis.readLong();
// If it is an array, decode it. The type will be "[x" where x is
  // translated according to the table
  private String getType(String type) {
          BaseType Character  Type  Interpretation
          B  byte  signed byte
          C  char  Unicode character
          D  double  double-precision floating-point value
          F  float  single-precision floating-point value
          I  int  integer
          J  long  long integer
          L<classname>;  reference  an instance of class <classname>
          S  short  signed short
          Z  boolean  true or false
          [  reference  one array dimension
    int arrayIndex = type.indexOf("[");
    if (arrayIndex != type.lastIndexOf("[")) {
      System.out.println("Multiple arrays not supported!");
      return type;
char tempType = type.charAt(arrayIndex + 1);
switch (tempType) {
case 'B':
type = "byte";
break;
case 'C':
type = "char";
break;
case 'D':
type = "double";
break;
case 'F':
type = "float";
break;
case 'I':
type = "int";
break;
case 'J':
type = "long";
break;
case 'S':
type = "short";
break;
default:
System.out.println("Couldn't define this type: " + type);
type = type;
break;
return type;
---End code---
Now the problem. I want to read the header of an executable. I turn to
the file format as described in WINNT.H. If it is a char, it will read
ok. For everything else, it doesn't work. A WORD (= short in java) for
instance, doesn't come up with the real value.
The purpose of this piece of code is to emulate the structs that are
used in C.
What is the problem here and what is the solution?

Answer 1

before coding a long class, look at Serialization mechanism in java
maybe (or maybe not) it should be a better soution ...