Come posso convertire un array di byte in double e back?

Question

Per la conversione di un array di byte ad un doppio ho trovato questo:

//convert 8 byte array to double 
int start=0;//??? 
int i = 0; 
    int len = 8; 
    int cnt = 0; 
    byte[] tmp = new byte[len]; 
    for (i = start; i < (start + len); i++) { 
     tmp[cnt] = arr[i]; 
     //System.out.println(java.lang.Byte.toString(arr[i]) + " " + i); 
     cnt++; 
    } 
    long accum = 0; 
    i = 0; 
    for (int shiftBy = 0; shiftBy < 64; shiftBy += 8) { 
     accum |= ((long)(tmp[i] & 0xff)) << shiftBy; 
     i++; 
    } 

     return Double.longBitsToDouble(accum); 

ma non ho trovato nulla che convertire una doppia in un array di byte.

Answer 1

long bits = Double.doubleToLongBits(myDouble); 

Answer 2

public static byte[] toByteArray(double d) { 
    long l = Double.doubleToRawLongBits(d); 
    return new byte[] { 
     (byte)((l >> 56) & 0xff), 
     (byte)((l >> 48) & 0xff), 
     (byte)((l >> 40) & 0xff), 
     (byte)((l >> 32) & 0xff), 
     (byte)((l >> 24) & 0xff), 
     (byte)((l >> 16) & 0xff), 
     (byte)((l >> 8) & 0xff), 
     (byte)((l >> 0) & 0xff), 
    }; 
} 

Answer 3

La funzionalità è implementata nel API già. Avvolgere l'array di byte in un ByteBuffer e utilizzare ByteBuffer.putLong e ByteBuffer.getLong:

import java.nio.*; 
import java.util.Arrays; 

public class Test { 
    public static void main(String... args) throws Exception { 

     long[] longArray = { 1234, 2345, 3456 }; 

     // Longs to bytes 
     byte[] bytes = new byte[longArray.length * 8]; 
     ByteBuffer buf = ByteBuffer.wrap(bytes); 
     for (long l : longArray) 
      buf.putLong(l); 

     System.out.println(Arrays.toString(bytes)); 

     // Bytes to longs 
     ByteBuffer buf2 = ByteBuffer.wrap(bytes); 
     long[] longs = new long[bytes.length/8]; 
     for (int i = 0; i < longs.length; i++) 
      longs[i] = buf2.getLong(i*8); 

     System.out.println(Arrays.toString(longs)); 

    } 
} 

uscita:

[0, 0, 0, 0, 0, 0, 4, -46, 0, 0, 0, 0, 0, 0, 9, 41, 0, 0, 0, 0, 0, 0, 13, -128] 
[1234, 2345, 3456] 

Answer 4

O ancora più semplice,

import java.nio.ByteBuffer; 

public static byte[] toByteArray(double value) { 
    byte[] bytes = new byte[8]; 
    ByteBuffer.wrap(bytes).putDouble(value); 
    return bytes; 
} 

public static double toDouble(byte[] bytes) { 
    return ByteBuffer.wrap(bytes).getDouble(); 
} 

Answer 5

Io in realtà sono imbattuto in problemi con superiore e inferiore del il doppio, questo sembra essere l'unico codice che ho visto che corregge per quello. Spero che assista gli altri alla ricerca di risposte in quest'area. se vai per un altro codice, assicurati di testare l'intero intervallo di valori, dovresti scrivere un ciclo che converta in e da tutti i valori e asserirlo per essere sicuro.

// byte2Double method - extracts doubles from byte array 
// source: http://www.java2s.com/Code/Java/Data-Type/bytetoDouble.htm 
    public static final double[] byte2Double(byte[] inData, boolean byteSwap) { 
    int j = 0, upper, lower; 
    int length = inData.length/8; 
    double[] outData = new double[length]; 
    if (!byteSwap) 
     for (int i = 0; i < length; i++) { 
     j = i * 8; 
     upper = (((inData[j] & 0xff) << 24) 
      + ((inData[j + 1] & 0xff) << 16) 
      + ((inData[j + 2] & 0xff) << 8) + ((inData[j + 3] & 0xff) << 0)); 
     lower = (((inData[j + 4] & 0xff) << 24) 
      + ((inData[j + 5] & 0xff) << 16) 
      + ((inData[j + 6] & 0xff) << 8) + ((inData[j + 7] & 0xff) << 0)); 
     outData[i] = Double.longBitsToDouble((((long) upper) << 32) 
      + (lower & 0xffffffffl)); 
     } 
    else 
     for (int i = 0; i < length; i++) { 
     j = i * 8; 
     upper = (((inData[j + 7] & 0xff) << 24) 
      + ((inData[j + 6] & 0xff) << 16) 
      + ((inData[j + 5] & 0xff) << 8) + ((inData[j + 4] & 0xff) << 0)); 
     lower = (((inData[j + 3] & 0xff) << 24) 
      + ((inData[j + 2] & 0xff) << 16) 
      + ((inData[j + 1] & 0xff) << 8) + ((inData[j] & 0xff) << 0)); 
     outData[i] = Double.longBitsToDouble((((long) upper) << 32) 
      + (lower & 0xffffffffl)); 
     } 

    return outData; 
    } 

Answer 6

public static final short byteArrayToShort(byte[] bytes) { 
    return ByteBuffer.wrap(bytes).getShort(); 
} 

public static final int byteArrayToInt(byte[] bytes) { 
    return ByteBuffer.wrap(bytes).getInt(); 
} 

public static final float byteArrayToFloat(byte[] bytes) { 
    return ByteBuffer.wrap(bytes).getFloat(); 
} 

public static double byteArrayToDouble(byte[] bytes) { 
    return ByteBuffer.wrap(bytes).getDouble(); 
} 

public static final long byteArrayToLong(byte[] bytes) { 
    return ByteBuffer.wrap(bytes).getLong(); 
} 

Go e godere.