Перевёрнутые числа в бинарном файле

[BLACK_RAIN]

Здравствуйте.
Есть две программы, написанные на C++ и Java. Они пишут числа в бинарный файл.
Необходимо, чтобы они могли читать данные, записанные друг другом.
Но вот проблема:
Java пишет так

            DataOutputStream dos = new DataOutputStream(new FileOutputStream(new File("bin.dat")));
            int x = 256;
            dos.writeShort((short)x);
            dos.writeInt(x);
            dos.close();
//HEX: 01 00 00 00 01 00

а WinAPI так

	
        DWORD dw = 0;
        int x = 256;
        WriteFile(fh, &x, sizeof(short), &dw, NULL);
        WriteFile(fh, &x, sizeof(int), &dw, NULL);
//HEX: 00 01 00 01 00 00

То есть, числа перевёрнуты. Почему так?
И как тогда на Java писать числа так же как в WinAPI, чтобы программа на С тоже могла их читать?
Понятно что можно переворачивать, но как?

[BDA]

Java сохраняет данные с порядком байтов Big Endian, а WinAPI, похоже, Little Endian. Не знаю, как именно правильно (быстро и эффективно) подгонять порядок на Java, но теперь вам будет что погуглить.

[Black Fregat]

Сообщение от BDA

WinAPI, похоже, Little Endian

WinAPI тупо пишет блок памяти. Как числа в памяти лежат, так и пишет.
А вот почему Java переворачивает - надо смотреть

Действительно, прямо в доке написано

writeInt(int v)
Writes an int to the underlying output stream as four bytes, high byte first.

StackOverflow предлагает использовать ByteBuffer

[BLACK_RAIN]

Сообщение от BDA

java сохраняет данные с порядком байтов Big Endian, а WinAPI, похоже, Little Endian.

Да, я это уже понял и написал классы

package xxx;

import java.io.*;

public class LittleEndianDataInputStream extends FilterInputStream implements DataInput {

    public LittleEndianDataInputStream(InputStream in) {
        super(in);
    }

    @Override
    public void readFully(byte[] b) throws IOException {

    }

    @Override
    public void readFully(byte[] b, int off, int len) throws IOException {

    }

    @Override
    public int skipBytes(int n) throws IOException {
        return 0;
    }

    @Override
    public boolean readBoolean() throws IOException {
        return false;
    }

    @Override
    public byte readByte() throws IOException {
        return 0;
    }

    @Override
    public int readUnsignedByte() throws IOException {
        return 0;
    }

    @Override
    public short readShort() throws IOException {
        int ch1 = in.read();
        int ch2 = in.read();
        if ((ch1 | ch2) < 0)
            throw new EOFException();
        return (short)(ch1 + (ch2 << 8));
    }

    @Override
    public int readUnsignedShort() throws IOException {
        return 0;
    }

    @Override
    public char readChar() throws IOException {
        return 0;
    }

    @Override
    public int readInt() throws IOException {
        int ch1 = in.read();
        int ch2 = in.read();
        int ch3 = in.read();
        int ch4 = in.read();
        if ((ch1 | ch2 | ch3 | ch4) < 0)
            throw new EOFException();
        return (ch1 << 24) + (ch2 << 16) + (ch3 << 8) + ch4 ;
    }

    @Override
    public long readLong() throws IOException {
        return 0;
    }

    @Override
    public float readFloat() throws IOException {
        return 0;
    }

    @Override
    public double readDouble() throws IOException {
        return 0;
    }

    @Override
    public String readLine() throws IOException {
        return null;
    }

    @Override
    public String readUTF() throws IOException {
        return null;
    }
}

package xxx;

import java.io.*;

public class LittleEndianDataOutputStream extends FilterOutputStream implements DataOutput {

    private int writtenBytes;

    public LittleEndianDataOutputStream(OutputStream out){
        super(out);
//        writtenBytes = 0;
    }

    private void incCount(int value) {
        int temp = writtenBytes + value;
        if (temp < 0) {
            temp = Integer.MAX_VALUE;
        }
        writtenBytes = temp;
    }

    @Override
    public void writeBoolean(boolean v) throws IOException {
        out.write(v ? 1 : 0);
        incCount(1);
    }

    @Override
    public void writeByte(int v) throws IOException {
        out.write(v);
        incCount(1);
    }

    @Override
    public void writeShort(int v) throws IOException {
        out.write(v & 0xFF);
        out.write((v >>> 8) & 0xFF);
        incCount(2);
    }

    @Override
    public void writeChar(int v) throws IOException {

    }

    @Override
    public void writeInt(int v) throws IOException {
        out.write((v >>> 24) & 0xFF);
        out.write((v >>> 16) & 0xFF);
        out.write((v >>>  8) & 0xFF);
        out.write((v >>>  0) & 0xFF);
        incCount(4);

    }

    @Override
    public void writeLong(long v) throws IOException {

    }

    @Override
    public void writeFloat(float v) throws IOException {

    }

    @Override
    public void writeDouble(double v) throws IOException {

    }

    @Override
    public void writeBytes(String s) throws IOException {

    }

    @Override
    public void writeChars(String s) throws IOException {

    }

    @Override
    public void writeUTF(String s) throws IOException {

    }

    public int size() {
        return writtenBytes;
    }
}

Теперь всё работает. Java пишет и читает Little endian. Но появился странный косяк. Массивы байт пишутся страшно медленно. Например, массив размером 4 мегабайта через стандартный DataOutputStream пишется мгновенно, а через мой класс за 12 секунд. Почему так? Я же в своём классе не оверрайдю метод, который пишет массив. Должен использоваться стандартный из FilterOutputStream.

[BDA]

FilterOutputStream.write:
Note that this method does not call the write method of its underlying input stream with the same arguments. Subclasses of FilterOutputStream should provide a more efficient implementation of this method

То есть DataOutputStream пишет более эффективно, чем FilterOutputStream.

[BLACK_RAIN]

просто надо было добавить метод

    public void write(byte b[]) throws IOException {
        out.write(b, 0, b.length);
        incCount(b.length);
    }

Тогда массив пишется одним вызовом и по-этому получается мгновенно.
Я думал, что этот метод уже где-то в базовых классах прописан.

Пардон, ошибочка вышла. Надо вот так:

//чтение
    @Override
    public short readShort() throws IOException {
        int ch1 = in.read();
        int ch2 = in.read();
        if ((ch1 | ch2) < 0)
            throw new EOFException();
        return (short)(ch1 + (ch2 << 8));
    }

    @Override
    public int readInt() throws IOException {
        int ch1 = in.read();
        int ch2 = in.read();
        int ch3 = in.read();
        int ch4 = in.read();
        if ((ch1 | ch2 | ch3 | ch4) < 0)
            throw new EOFException();
        return ch1 + (ch2 << 8) + (ch3 << 16) + (ch4 << 24);
    }

//запись
    @Override
    public void writeShort(int v) throws IOException {
        out.write(v & 0xFF);
        out.write((v >> 8) & 0xFF);
        incCount(2);
    }

    @Override
    public void writeInt(int v) throws IOException {
        out.write(v & 0xFF);
        out.write((v >> 8) & 0xFF);
        out.write((v >> 16) & 0xFF);
        out.write((v >> 24) & 0xFF);
        incCount(4);
    }

Кстати, в оригинальных классах используются три хрени >>> хотя работает и с двумя.
В чем разница, две или три?

[BDA]

>>> - беззнаковый сдвиг (в старшие биты всегда будет записываться 0), а >> - знаковый (в старшие биты запишется значение знакового бита). В данном случае срабатывают одинаково из-за масок, которые отбрасывают те биты, в которых будет различие.