long - short java ejemplo

Convertir corto a byte[] en Java

Question

¿Cómo puedo convertir un short (2 bytes) a una matriz de bytes en Java, por ejemplo,

short x = 233;
byte[] ret = new byte[2];
...

Debería ser algo como esto. Pero no estoy seguro.

((0xFF << 8) & x) >> 0;

EDITAR:

También puedes usar:

java.nio.ByteOrder.nativeOrder();

Descubrir para obtener si el orden de bits nativo es grande o pequeño. Además, el siguiente código se toma de java.io.Bits que hace:

• byte (array / offset) a booleano
• byte array a char
• byte array a corto
• byte array a int
• matriz de bytes para flotar
• byte array a long
• matriz de bytes para duplicar

Y viceversa.

Answer 1

Depende de cómo quieras representarlo:

• big endian o little endian? Eso determinará en qué orden colocas los bytes.

• ¿Quieres usar el complemento de 2 o alguna otra forma de representar un número negativo? Debe usar un esquema que tenga el mismo rango que el corto en java para tener una asignación 1 a 1.

Para Big Endian, la transformación debe ser en la línea de: ret [0] = x / 256; ret [1] = x% 256;

Answer 2

Lo descubrí, es:

public static byte[] toBytes(short s) {
return new byte[]{(byte)(s & 0x00FF),(byte)((s & 0xFF00)>>8)};
}

Answer 3

Método de conversión de corto a bytes En Kotlin funciona para mí:

 fun toBytes(s: Short): ByteArray {
return byteArrayOf((s.toInt() and 0x00FF).toByte(), ((s.toInt() and 0xFF00) shr (8)).toByte())
}

Answer 4

Una alternativa más eficiente:

 // Little Endian
ret[0] = (byte) x;
ret[1] = (byte) (x >> 8);
// Big Endian
ret[0] = (byte) (x >> 8);
ret[1] = (byte) x;

Answer 5

Una solución más limpia, aunque mucho menos eficiente es:

ByteBuffer buffer = ByteBuffer.allocate(2);
buffer.putShort(value);
return buffer.array();

Tenga esto en cuenta cuando tenga que realizar transformaciones de bytes más complejas en el futuro. Los ByteBuffers son muy poderosos.

Answer 6

Varios métodos han sido mencionados aquí. Pero, ¿cuál es el mejor? Aquí sigue una prueba de que los siguientes 3 enfoques dan como resultado la misma salida para todos los valores de un short

 // loops through all the values of a Short
short i = Short.MIN_VALUE;
do
{
// method 1: A SIMPLE SHIFT
byte a1 = (byte) (i >> 8);
byte a2 = (byte) i;
// method 2: AN UNSIGNED SHIFT
byte b1 = (byte) (i >>> 8);
byte b2 = (byte) i;
// method 3: SHIFT AND MASK
byte c1 = (byte) (i >> 8 & 0xFF);
byte c2 = (byte) (i & 0xFF);
if (a1 != b1 || a1 != c1 ||
a2 != b2 || a2 != c2)
{
// this point is never reached !!
}
} while (i++ != Short.MAX_VALUE);

Conclusión: menos es más?

byte b1 = (byte) (s >> 8);
byte b2 = (byte) s;

(Como han mencionado otras respuestas, tenga cuidado con LE/BE ).

Answer 7

corto a byte

short x=17000;
byte res[]=new byte[2];
res[i]= (byte)(((short)(x>>7)) & ((short)0x7f) | 0x80 );
res[i+1]= (byte)((x & ((short)0x7f)));

byte a corto

short x=(short)(128*((byte)(res[i] &(byte)0x7f))+res[i+1]);

Answer 8

public short bytesToShort(byte[] bytes) {
return ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).getShort();
}
public byte[] shortToBytes(short value) {
byte[] returnByteArray = new byte[2];
returnByteArray[0] = (byte) (value & 0xff);
returnByteArray[1] = (byte) ((value >>> 8) & 0xff);
return returnByteArray;
}

Answer 9

ret[0] = (byte)(x & 0xff);
ret[1] = (byte)((x >> 8) & 0xff);