CODEWITHSUNDEEP
javatype-conversionbyteshort
Nilesh
Nilesh

Reputation:

2 bytes to short

I'm reading a packet with a length of 133 bytes from the serialport, the last 2 bytes contain the CRC values, 2 byte values I've made single (short I think) using Java.

This what I have done:

short high = (-48 & 0x00ff);
short low = 80;

short c = (short) ((high << 8) + low);

But I'm not getting the correct result. Is it a problem because of the use of signed values? How can I solve this problem?

Upvotes: 36

Views: 78777

Answers (6)

Pwn
Pwn

Reputation: 318

This works for me

short temp = ;
result[0] = (byte) ((temp >>> 8) & 0xFF);
result[1] = (byte)((temp) & 0xFF);

Upvotes: 0

Mariusz Wiazowski
Mariusz Wiazowski

Reputation: 2446

You can convert 2 bytes to a short in a more readable and elegant way.

short s = ByteBuffer.wrap(new byte[]{0x01, 0x02}).getShort();
// now s equals 258 = 256 + 2

The first byte is the most significant byte.

Upvotes: 8

L. Cornelius Dol
L. Cornelius Dol

Reputation: 64064

When converting byte values from a stream into numeric values in Java you have to be very careful with sign extension. There is a trap with negative numbers (values from (unsigned) 128-255).

Try this (it works if hi and lo are any Java integer type) :

short val=(short)(((hi & 0xFF) << 8) | (lo & 0xFF));

I find it's best to be explicit with the parentheses in these cases.

Upvotes: 35

Lake
Lake

Reputation: 4092

This happens when trying to concatenate bytes (very subtle)

byte b1 = (byte) 0xAD;
byte b2 = (byte) 0xCA;
short s = (short) (b1<<8 | b2);

The above produces 0xFFCA, which is wrong. This is because b2 is negative (byte type is signed!), which means that when it will get converted to int type for the bit-wise | operation, it will be left-padded with 0xF!

Therefore, you must remember to mask-out the padded bytes so that they will definitely be zero:

short s = (short) (b1<<8 | b2 & 0xFF);

Upvotes: 14

akarnokd
akarnokd

Reputation: 70017

The other answers are OK, but I would like to put an emphasis on the type:

short high=(-48 & 0x00ff);
short low=80;

int c= ((high & 0xFF) << 8) | (low & 0xFF);

The short type can represent values between -32768 to 32767. 53328 cannot be nicely stored in short, use int instead as it allows you to store unsigned value up to ~109 So don't downcast the expression to short as it will net you the signed value.

Upvotes: 11

Neil Coffey
Neil Coffey

Reputation: 21815

Remember, you don't have to tie yourself in knots with bit shifting if you're not too familiar with the details. You can use a ByteBuffer to help you out:

ByteBuffer bb = ByteBuffer.allocate(2);
bb.order(ByteOrder.LITTLE_ENDIAN);
bb.put(firstByte);
bb.put(secondByte);
short shortVal = bb.getShort(0);

And vice versa, you can put a short, then pull out bytes.

By the way, bitwise operations automatically promote the operands to at least the width of an int. There's really no notion of "not being allowed to shift a byte more than 7 bits" and other rumours that seem to be going round.

Upvotes: 69

Related Questions