Comment convertir une variable short
(2 octets) en un tableau d'octets en Java, par exemple.
short x = 233;
byte[] ret = new byte[2];
...
ça devrait être quelque chose comme ça. Mais pas sûr.
((0xFF << 8) & x) >> 0;
MODIFIER:
Aussi, vous pouvez utiliser:
Java.nio.ByteOrder.nativeOrder();
Pour savoir si l'ordre des bits natif est grand ou petit. De plus, le code suivant provient de Java.io.Bits
qui le fait:
Et vice versa.
ret[0] = (byte)(x & 0xff);
ret[1] = (byte)((x >> 8) & 0xff);
Une solution plus propre, bien que beaucoup moins efficace, est:
ByteBuffer buffer = ByteBuffer.allocate(2);
buffer.putShort(value);
return buffer.array();
Gardez cela à l’esprit lorsque vous devez effectuer des transformations d’octets plus complexes à l’avenir. Les ByteBuffers sont très puissants.
Une alternative plus efficace:
// Little Endian
ret[0] = (byte) x;
ret[1] = (byte) (x >> 8);
// Big Endian
ret[0] = (byte) (x >> 8);
ret[1] = (byte) x;
Je l'ai compris, c'est:
public static byte[] toBytes(short s) {
return new byte[]{(byte)(s & 0x00FF),(byte)((s & 0xFF00)>>8)};
}
Cela dépend comment vous voulez le représenter:
big Endian ou petit Endian? Cela déterminera l'ordre dans lequel vous mettez les octets.
Voulez-vous utiliser le complément à 2 ou une autre manière de représenter un nombre négatif? Vous devez utiliser un schéma ayant la même plage que le raccourci en Java pour obtenir un mappage 1 à 1.
Pour le big endian, la transformation devrait aller dans le sens de: ret [0] = x/256; ret [1] = x% 256;
Méthode de conversion de court à octets In Kotlin fonctionne pour moi:
fun toBytes(s: Short): ByteArray {
return byteArrayOf((s.toInt() and 0x00FF).toByte(), ((s.toInt() and 0xFF00) shr (8)).toByte())
}
Plusieurs méthodes ont été mentionnées ici. Mais lequel est le meilleur? Voici quelques preuves que les 3 approches suivantes donnent le même résultat pour toutes les valeurs de 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);
Conclusion: moins c'est plus?
byte b1 = (byte) (s >> 8);
byte b2 = (byte) s;
(Comme d'autres réponses l'ont mentionné, faites attention à LE/BE ).
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;
}
court à octet
short x=17000;
byte res[]=new byte[2];
res[i]= (byte)(((short)(x>>7)) & ((short)0x7f) | 0x80 );
res[i+1]= (byte)((x & ((short)0x7f)));
octet à court
short x=(short)(128*((byte)(res[i] &(byte)0x7f))+res[i+1]);