Лучший способ читать структурированные двоичные файлы с помощью Java

Насколько мне известно, Java заставляет вас читать файл как байты, а не блокировать чтение. Если бы вы сериализовали объекты Java, это была бы другая история.

В других показанных примерах используется класс DataInputStream с файл, но вы также можете использовать ярлык: RandomAccessFile класс:

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);

Обратите внимание, что вы можете превратить объекты ответа в класс, если это упростит задачу.

Если вы будете использовать Preon, вам нужно будет сделать следующее:

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

Получив это, вы создаете кодек, используя одну строку:

Codec<Header> codec = Codecs.create(Header.class);

И вы используете кодек следующим образом:

Header header = Codecs.decode(codec, file);

Вы можете использовать класс DataInputStream следующим образом:

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

etc.

Как только вы получите эти значения, вы можете делать с ними все, что вам заблагорассудится. Найдите класс java.io.DataInputStream в API для получения дополнительной информации.

Возможно, я вас неправильно понял, но мне кажется, что вы создаете структуры в памяти, которые, как вы надеетесь, будут точным представлением того, что вы хотите прочитать с жесткого диска, а затем копируете все это в память и манипулировать оттуда?

Если это действительно так, вы играете в очень опасную игру. По крайней мере, в C стандарт не требует таких вещей, как заполнение или выравнивание элементов структуры. Не говоря уже о таких вещах, как большой/малый порядок байтов или биты четности... Поэтому, даже если ваш код запускается, он очень непереносим и рискован - вы зависите от создателя компилятора, который не изменит свое мнение о будущих версиях.

Лучше создать автомат для проверки правильности считываемой структуры (байт за байтом) из HD и заполнения структуры в памяти, если она действительно в порядке. Вы можете потерять несколько миллисекунд (не так много, как может показаться, поскольку современные ОС часто кэшируют чтение с диска), хотя вы получаете независимость от платформы и компилятора. Кроме того, ваш код будет легко перенесен на другой язык.

Post Edit: В каком-то смысле я вам сочувствую. В старые добрые времена DOS/Win3.11 я однажды создал программу на C для чтения файлов BMP. И использовал точно такую ​​же технику. Все было хорошо, пока я не попытался скомпилировать его для Windows - упс!! Int теперь имел длину 32 бита, а не 16! Когда я попытался скомпилировать в Linux, обнаружил, что у gcc совсем другие правила распределения битовых полей, чем у Microsoft C (6.0!). Мне пришлось прибегнуть к трюкам с макросами, чтобы сделать его переносимым...

Я использовал Javolution и javastruct, оба обрабатывают преобразование между байтами и объектами.

Javolution предоставляет классы, представляющие типы C. Все, что вам нужно сделать, это написать класс, описывающий структуру C. Например, из заголовочного файла C

struct Date {
    unsigned short year;
    unsigned byte month;
    unsigned byte day;
};

следует перевести на:

public static class Date extends Struct {
    public final Unsigned16 year = new Unsigned16();
    public final Unsigned8 month = new Unsigned8();
    public final Unsigned8 day   = new Unsigned8();
}

Затем вызовите setByteBuffer для инициализации объекта:

Date date = new Date();
date.setByteBuffer(ByteBuffer.wrap(bytes), 0);

javastruct использует аннотации для определения полей в структуре C.

@StructClass
public class Foo{

    @StructField(order = 0)
    public byte b;

    @StructField(order = 1)
    public int i;
}

Чтобы инициализировать объект:

Foo f2 = new Foo();
JavaStruct.unpack(f2, b);

Я предполагаю, что FileInputStream позволяет вам читать в байтах. Итак, открываем файл с помощью FileInputStream и читаем sizeof(header). Я предполагаю, что заголовок имеет фиксированный формат и размер. Я не вижу, чтобы это упоминалось в начальном сообщении, но предполагаю, что это так, поскольку было бы намного сложнее, если бы заголовок имел необязательные аргументы и разные размеры.

Когда у вас есть информация, может быть класс заголовка, в котором вы назначаете содержимое буфера, который вы уже прочитали. А затем аналогичным образом проанализируйте записи.

Вот ссылка для чтения байта с помощью ByteBuffer (Java NIO)

http://exampledepot.com/egs/java.nio/ReadChannel.html

Как упоминают другие люди, DataInputStream и Buffers, вероятно, являются низкоуровневыми API, которые вам нужны для работы с двоичными данными в java.

Однако вы, вероятно, захотите что-то вроде Construct (на вики-странице тоже есть хорошие примеры: http://en.wikipedia.org/wiki/Construct_(python_library)), но для Java.

Я не знаю ни одной (версии Java) из рук, но использование этого подхода (декларативное указание структуры в коде), вероятно, было бы правильным путем. С подходящим свободным интерфейсом на Java он, вероятно, будет очень похож на DSL.

РЕДАКТИРОВАТЬ: немного поиска в Google показывает это:

http://javolution.org/api/javolution/io/Struct.html

Что может быть тем, что вы ищете. Я понятия не имею, работает ли это или хорошо, но это похоже на разумное место для начала.

Я бы создал объект, который обертывает ByteBuffer. представление данных и предоставить геттерам возможность чтения непосредственно из буфера. Таким образом, вы избегаете копирования данных из буфера в примитивные типы. Кроме того, вы можете использовать MappedByteBuffer чтобы получить байтовый буфер. Если ваши двоичные данные сложны, вы можете смоделировать их с помощью классов и дать каждому классу нарезанную версию вашего буфера.

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);
    }
}

Также полезны методы чтения значений без знака из байтовых буферов.

ХТН

Я написал метод, позволяющий делать такие вещи в java, похожий на старую C-подобную идиому чтения битовых полей. Обратите внимание, что это только начало, но его можно расширить.

здесь

Раньше я использовал DataInputStream для чтения данных произвольных типов в указанном порядке. Это не позволит вам легко учитывать проблемы с прямым порядком байтов/обратным порядком байтов.

Начиная с версии 1.4, возможно, подойдет семейство java.nio.Buffer, но кажется, что ваш код на самом деле может быть более сложным. Эти классы поддерживают обработку проблем с порядком байтов.

Некоторое время назад я нашел эту статью об использовании отражения и синтаксического анализа для чтения двоичных данных. В этом случае автор использует отражение для чтения бинарных файлов Java .class. Но если вы читаете данные в файл класса, это может помочь.