Convierte float [] en byte [] en float [] nuevamente

Question

Lo que trato de hacer aquí es obtener float[], convertirlo a byte[], enviarlo a través de la red como un paquete de datagramas y luego convertirlo de nuevo a a byte[] en la terminal receptora.

Ahora sé que puedo convertir float[] en byte[] usando el método getBytes[]. Pero no sé cómo invertir la conversión.

Answer 1

Creo que desee hacer uso de la clase ByteBuffer, que tiene putFloat y getFloat métodos.

Answer 2

La clase Byte tiene un método floatValue();

http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Byte.html#floatValue%28%29

Answer 3

Utilice Float.floatToIntBits() para extraer el valor de bit del flotador como un entero, luego use BigInteger.toByteArray() para hacer un byte[]. Esto se puede revertir utilizando el constructor BigInteger que toma un argumento byte[] y luego Float.intBitsToFloat().

Answer 4

Otra forma de usar ... ByteArrayOutputStream/DataOutputStream para la salida

float fArr[] = ...; 
ByteArrayOutputStream bas = new ByteArrayOutputStream(); 
DataOutputStream ds = new DataOutputStream(bas); 
for (float f : fArr) 
    ds.writeFloat(f); 
byte[] bytes = bas.toByteArray(); 

Uso ByteArrayInputStream/DataInputStream para la entrada

byte[] buffer = ...; 
ByteArrayInputStream bas = new ByteArrayInputStream(buffer); 
DataInputStream ds = new DataInputStream(bas); 
float[] fArr = new float[buffer.length/4]; // 4 bytes per float 
for (int i = 0; i < fArr.length; i++) 
{ 
    fArr[i] = ds.readFloat(); 
} 

Answer 5

remitente:

ByteArrayOutputStream byteStream = new ByteArrayOutputStream(); 
// byteBuffer reused for every element in floatArray 
ByteBuffer byteBuffer = ByteBuffer.allocate(4); 
// go through the elements in the float array writing its 
// byte equivalent to the stream 
for(float element : floatArray) { 
    byteBuffer.clear(); 
    byteBuffer.putFloat(element) 
    byteStream.write(byteBuffer.array()); 
} 

// Logic for sending bytestream's bytes as datagram packet 
// can get byte[] from steam by: byteStream.toByteArray(); 

receptor:

ArrayList<Float> receivedValues = new ArrayList<Float>(); 
ByteBuffer byteBuffer = ByteBuffer.wrap(receivedBytes); 

// while there is still 4 bytes left on the byte buffer 
// grab the next float and add it to the received list 
int position = 0; 
while(byteBuffer.capactiy - position >= 4) { 
    receivedValues.add(byteBuffer.getFloat(position)); 
    position += 4; 
} 

float[] result = new float[receivedValues.count]; 
return receivedValues.toArray(new float[receivedValues.size()]); 

Answer 6

Es necesario utilizar el getFloat() y putFloat() comandos en el FloatBuffer del ByteBuffer. De hecho, seguramente deberías hacer esto simplemente por la gran velocidad. Y es algo grandioso de entender por manipulaciones de byte. También puede mezclar y combinar los datos, y ponerlos y obtenerlos según sea necesario. Todo está respaldado por el buffer de byte. Por lo tanto, el hecho común de enviar una matriz, también debe enviar el tamaño de la matriz.

public static void writeFloatArray(float[] array, OutputStream stream) throws IOException { 
    ByteBuffer buffer = ByteBuffer.allocate(4 * (array.length + 1)).putInt(array.length); 
    buffer.asFloatBuffer().put(array,0,array.length); 
    stream.write(buffer.array()); 
} 

Simplemente asegúrese de asignar suficientes bytes para almacenar todo en el búfer. Escribe algunas cosas, escribe otras cosas, etc. Comprender este punto hace las cosas mucho más fáciles. En el otro lado hacemos básicamente la misma cosa, aunque se requiere una lectura adicional, ya que no sabemos qué tan grande es la matriz, sólo que hay una:

public static float[] readFloatArray(InputStream in) throws IOException { 
    byte[] data = new byte[4]; 
    if (readFully(in, data) != data.length) return null; 
    int length = ByteBuffer.wrap(data).getInt(); 
    data = new byte[length * 4]; 
    if (readFully(in,data) != data.length) return null; 
    float[] array = new float[length]; 
    ByteBuffer.wrap(data).asFloatBuffer().get(array,0,array.length); 
    return array; 
} 

Y para la funcionalidad completa, aunque no exactamente parte de esta:

public static int readFully(InputStream in, byte[] data) throws IOException { 
    int offset = 0; 
    int bytesRead; 
    boolean read = false; 
    while ((bytesRead = in.read(data, offset, data.length - offset)) != -1) { 
     read = true; 
     offset += bytesRead; 
     if (offset >= data.length) { 
      break; 
     } 
    } 
    return (read) ? offset : -1; 
}