Byte Array to *Signed* Int

Question

I'm trying to convert -101 to a byte array and then convert the byte array back to -101. My methods below work for positive values but not for negative values. Can you suggest what I'm doing wrong? Instead of -101, the byteArrayToInt method returns 65435. Thanks!

/**
 * Converts a <code>byte</code> array to a 32-bit <code>int</code>.
 * 
 * @param array The <code>byte</code> array to convert.
 * @return The 32-bit <code>int</code> value.
 */
public static int byteArrayToInt(byte[] array) {
  ValidationUtils.checkNull(array);
  int value = 0;

  for (int i = 0; i < array.length; i++) {
    int shift = (array.length - 1 - i) * 8;
    value = value | (array[i] & 0xFF) << shift;
  }

  return value;
}

/**
 * Converts a 32-bit <code>int</code> to a <code>byte</code> array.
 * 
 * @param value The 32-bit <code>int</code> to convert.
 * @return The <code>byte</code> array.
 */
public static byte[] intToByteArray(int value, int size) {
  byte[] bytes = new byte[size];
  for (int index = 0; index < bytes.length; index++) {
    bytes[index] = (byte) (value >>> (8 * (size - index - 1)));
  }
  return bytes;
}

/**
 * Tests the utility methods in this class.
 * 
 * @param args None.
 */
public static void main(String... args) {
  System.out.println(byteArrayToInt(intToByteArray(32, 2)) == 32); // true
  System.out.println(byteArrayToInt(intToByteArray(64, 4)) == 64); // true
  System.out.println(byteArrayToInt(intToByteArray(-101, 2)) == -101); // false
  System.out.println(byteArrayToInt(intToByteArray(-101, 4)) == -101); // true
}

Answer 1

You need to sign-extend your number. If you haven't already, you should read up on two's complement representation for signed binary numbers.

The number -101 as a 32-bit integer is 0xFFFFFF9B in hex. You convert it to a byte array of 2 bytes. That leaves just 0xFF9B. Now, when you convert it back you convert it into a 32-bit integer and the result is 0x0000FF9B, or 65435 in decimal.

You should check the highest-order bit in your byte array and sign extend based on that. A simple way to do it would be to start with value=-1 if the highest-order bit is set and default to value=0 if it isn't.

Edit: An easy way to check the highest-order bit is to check if the high-order-byte is negative.