convert byte array to double

I made a little example to see, how the converting could be done back and forth.

Hope it helps.

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

public class ByteToDouble {

    public static void main(String[] args) throws IOException {
        double d1 = 123.456;
        double d2 = bytesToDouble(doubleToBytes(d1));

        System.out.printf("d1: %f\nd2: %f\n", d1, d2);
    }

    public static byte[] doubleToBytes(double d) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeDouble(d);
        dos.flush();
        return bos.toByteArray();
    }

    public static double bytesToDouble(byte[] bytes) {
        ByteBuffer buffer = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN);
        return buffer.getDouble();
    }
}

Note that the ByteBuffer#getDouble() method will throw an BufferUnderflowException, if there are fewer than eight bytes remaining in the buffer. (see JavaDoc)

In your code you use

m_ByteBuffer.get(_data);

which would read the data of the buffer into _data. I suppose what you wanted to use was ByteBuffer#put

m_ByteBuffer.put(_data);

Additionally, after putting data into the buffer, it is more common to use flip instead of position(0) since that correctly sets the limit of the buffer. All in all this would result roughly in:

m_ByteBuffer.order(_endian);

m_ByteBuffer.clear();
m_ByteBuffer.put(_data);
m_ByteBuffer.flip();
m_ByteBuffer.getDouble();

4 bytes represent a float, 8 bytes a double.

byte[] data = {0x6D, 0xF3, 0xB4, 0x15};
double x = bytesToDouble(data);

public static double bytesToDouble(byte[] data) {
    ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
    return data.length == 4 ? bb.getFloat() : bb.getDouble();
}

ByteBuffer.wrap(byte[]) is a light weight wrapping of the array, with writing capability to the bytes. A global ByteBuffer is not necessarily faster, certainly not when needing synchronisation.