Konwertuj skrót na bajt [] w Javie

Czystszym, aczkolwiek znacznie mniej wydajnym rozwiązaniem jest:

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

Pamiętaj o tym, gdy w przyszłości będziesz musiał wykonać bardziej złożone transformacje bajtów. Bytebuffery są bardzo potężne.

Alternatywa, która jest bardziej efektywna:

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

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

Rozgryzłem to, its:

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

To zależy jak chcesz to reprezentować:

• Big endian czy little endian? To określi, w jakiej kolejności umieścisz bajty.

• Czy chcesz użyć dopełniacza 2 lub innego sposobu reprezentowania liczby ujemnej? Należy użyć schematu, który ma taki sam zakres jak krótki w Javie, aby mieć mapowanie 1-to-1.

Dla big endian transformacja powinna być zgodna z: ret[0] = x/256; ret[1] = x%256;

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;
}

Kilka metod zostało tutaj wymienionych. Ale który jest najlepszy? Poniżej przedstawiamy dowód, że następujące 3 podejścia dają taki sam wynik dla wszystkich wartości 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);

Wniosek: mniej znaczy więcej ?

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

(Jak już wspomniano w innych odpowiedziach, uważaj na LE / BE ).

Metoda konwersji krótkich na bajty w Kotlinie działa dla mnie:

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

Skrót do bajtu

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 to short

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