how to read signed int from bytes in java?

I have a spec which reads the next two bytes are signed int.

To read that in java i have the following

When i read a signed int in java using the following code i get a value of 65449

Logic for calculation of unsigned

int a =(byte[1] & 0xff) <<8

int b =(byte[0] & 0xff) <<0

int c = a+b 

I believe this is wrong because if i and with 0xff i get an unsigned equivalent

so i removed the & 0xff and the logic as given below

int a = byte[1] <<8
int b = byte[0] << 0
int c = a+b
which gives me the value -343
byte[1] =-1
byte[0]=-87

I tried to offset these values with the way the spec reads but this looks wrong.Since the size of the heap doesnt fall under this.

Which is the right way to do for signed int calculation in java?

Here is how the spec goes

somespec() { xtype 8 uint8 xStyle 16 int16 } xStyle :A signed integer that represents an offset (in bytes) from the start of this Widget() structure to the start of an xStyle() structure that expresses inherited styles for defined by page widget as w开发者_开发问答ell as styles that apply specifically to this widget.

If you value is a signed 16-bit you want a short and int is 32-bit which can also hold the same values but not so naturally.

It appears you wants a signed little endian 16-bit value.

byte[] bytes = 
short s = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).getShort();

or

short s = (short) ((bytes[0] & 0xff) | (bytes[1] << 8));

BTW: You can use an int but its not so simple.

// to get a sign extension.
int i = ((bytes[0] & 0xff) | (bytes[1] << 8)) << 16 >> 16;

or

int i = (bytes[0] & 0xff) | (short) (bytes[1] << 8));

Assuming that bytes[1] is the MSB, and bytes[0] is the LSB, and that you want the answer to be a 16 bit signed integer:

short res16 = ((bytes[1] << 8) | bytes[0]);

Then to get a 32 bit signed integer:

int res32 = res16;  // sign extends.

By the way, the specification should say which of the two bytes is the MSB, and which is the LSB. If it doesn't and if there aren't any examples, you can't implement it!

Somewhere in the spec it will say how an "int16" is represented. Paste THAT part. Or paste a link to the spec so that we can read it ourselves.

Take a look on DataInputStream.readInt(). You can either steel code from there or just use DataInputStream: wrap your input stream with it and then read typed data easily.

For your convenience this is the code:

public final int readInt() throws IOException {
    int ch1 = in.read();
    int ch2 = in.read();
    int ch3 = in.read();
    int ch4 = in.read();
    if ((ch1 | ch2 | ch3 | ch4) < 0)
        throw new EOFException();
    return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
}

I can't compile it right now, but I would do (assuming byte1 and byte0 are realling of byte type).

 int result = byte1;
 result = result << 8;
 result = result | byte0;  //(binary OR)
 if (result & 0x8000 == 0x8000) { //sign extension
   result = result | 0xFFFF0000;
 }

if byte1 and byte0 are ints, you will need to make the `&0xFF

UPDATE because Java forces the expression of an if to be a boolean

do you have a way of finding a correct output for a given input? technically, an int size is 4 bytes, so with just 2 bytes you can't reach the sign bit.

I ran across this same problem reading a MIDI file. A MIDI file has signed 16 bit as well as signed 32 bit integers. In a MIDI file, the most significant bytes come first (big-endian).

Here's what I did. It might be crude, but it maintains the sign. If the least significant bytes come first (little-endian), reverse the order of the indexes.

pos is the position in the byte array where the number starts.

length is the length of the integer, either 2 or 4. Yes, a 2 byte integer is a short, but we all work with ints.

private int convertBytes(byte[] number, int pos, int length) {
    int output = 0;
    if (length == 2) {
        output = ((int) number[pos]) << 24;
        output |= convertByte(number[pos + 1]) << 16;
        output >>= 16;
    } else if (length == 4) {
        output = ((int) number[pos]) << 24;
        output |= convertByte(number[pos + 1]) << 16;
        output |= convertByte(number[pos + 2]) << 8;
        output |= convertByte(number[pos + 3]);
    }
    return output;
}

private int convertByte(byte number) {
    return (int) number & 0xff;
}