Преобразование short to byte [] в Java

Question

Как преобразовать short (2 байта) в массив байтов в Java, например.

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

... 

Это должно быть что-то вроде этого. Но не уверен.

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

EDIT:

Также вы можете использовать:

java.nio.ByteOrder.nativeOrder(); 

Для того, чтобы открыть, чтобы получить ли большой или маленький родной порядок битов. Кроме того, следующий код берется из java.io.Bits, который делает:

• байт (массив/смещение), чтобы булева
• массива байт на символ
• массива байт в короткий массив
• байт в целое
• байтовый массив, чтобы плавать
• массив байтов в массиве длинного
• байт в два раза

И наоборот.

Answer 1

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

Answer 2

Фигурные это, его:

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

Answer 3

Это зависит от того, как вы хотите, чтобы представить его:

• большой Endian или Little Endian? Это определит, в каком порядке вы помещаете байты.

• Вы хотите использовать дополнение 2 или какой-либо другой способ представления отрицательного числа? Вы должны использовать схему, которая имеет тот же диапазон, что и short в java, для отображения 1 к 1.

Для больших обратного порядка байт, преобразование должно быть вдоль линий: в отставке [0] = х/256; ret [1] = x% 256;

Answer 4

уборщик, хотя и гораздо менее эффективным решением является:

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

Имейте это в виду, когда вы должны сделать более сложные преобразования байтов в будущем. ByteBuffers очень мощные.

Answer 5

Альтернатива, которая является более эффективным:

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

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

Answer 6

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 7

Несколько методов были упомянуты здесь. Но какой из них лучше?Далее следует некоторые доказательства того, что следующие 3 подхода приводят к одной и той же продукции для всех значений 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); 

Вывод: чем меньше, больше?

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

(Как и другие ответы уже упоминалось, следить за LE/BE).

Answer 8

короткое байт

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

байт короткий

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

Answer 9

Замыкание байт преобразовать метод В Котлин работает для меня:

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