带符号字节的按位AND运算

Question

Here is the code:

int i = 200;
byte b = (byte) 200;
System.out.println(b);
System.out.println((short) (b));
System.out.println((b & 0xff));
System.out.println((short) (b & 0xff));

Here is the output:

-56
-56
200
200

Bitwise AND with 0xff shouldn't have changed anything in b , but apparently it does have an effect, why?

Answer 1

It has an effect because 200 is beyond the maximum possible (signed) byte , 127 . The value is already assigned -56 because of this overflow. The most significant byte, worth -128 , is set.

11001000

The first 2 output statements show -56 because of this, and the fact that casting to a short will perform sign extension to preserve negative values.

When you perform & 0xff , 2 things happen. First, the value is promoted to an int , with sign extension.

11111111 11111111 11111111 11001000

Then, the bit-and is performed, keeping only the last 8 bits. Here, the 8th bit is no longer -128 , but 128 , so 200 is restored.

00000000 00000000 00000000 11001000

This occurs whether the value is casted to a short or not; a short has 16 bits and can easily represent 200 .

00000000 11001000

Answer 2

Java byte is a signed type. That is why you see a negative number when you print it: 200, or 0xC8 , is above the largest positive number representable by byte , so it gets interpreted as a negative byte .

However, 0xff constant is an int . When you perform arithmetic and bitwise logic operations on a byte and an int ^* , the result becomes an int . That is why you see 200 printed in the second set of examples: (b & 0xff) produces an integer 200 , which remains 200 after shrinking conversion to short , because 200 fits into a short without becoming negative.

^* or another byte , for that matter; Java standard specifies a list of conversions that get applied depending on operand types.

Answer 3

working with different integer types is a mine field.

for example, what's going on here?

byte b = (byte) 200;

it's actually equivalent to

int i = 200;
byte b = (byte)i;

and the narrowing cast (byte) simply takes the lowest 8 bits of the int value.