Why does converting an int to a byte in Java result in a negative value, and how can we retrieve the original unsigned value?

Intriguing Int and Byte Conversion Anomalies

When converting an int to a byte in Java, behavior may seem unexpected, particularly when considering the apparent loss of data and the negative sign assigned to the resulting byte. To unravel this enigma, let's delve into the intricacies of primitive data types and two's complement representation.

Understanding Primitive Types and Two's Complement:

In Java, an int occupies 32 bits, while a byte occupies a mere 8 bits. Moreover, primitive types like int and byte follow the two's complement representation. In this scheme, the highest bit (MSB) determines the sign, and additional bits lead to its replication.

Bitwise Conversion from Int to Byte:

When converting an int to a byte, Java extracts only the 8 least significant bits and assigns the value accordingly. However, the MSB of an int, now the sign bit of the byte, plays a significant role in the outcome.

Revealing the Hidden Truth:

Let's dissect our perplexing example:

int i = 132;

byte b = (byte)i; // Implicit narrowing conversion

System.out.println(b); // Prints -124

The 32-bit binary representation of 132:

00000000000000000000000010000100

Extracting the 8 least significant bits (10000100):

10000100

Converting to two's complement representation:

11111000

Java interprets this as a negative value due to the inverted bit pattern, resulting in -124 being printed.

Resolving the Enigma:

To retrieve the original 8-bit unsigned value of the byte, we can perform a bitwise AND operation:

byte signedByte = -124;
int unsignedByte = signedByte & 0xff; // 0xff = 11111111b

This operation masks off the extraneous sign bits, yielding the following result:

Unsigned value: 10000100 (84 in decimal)

Summarizing the Trickery:

During the int-to-byte conversion, Java disregards the leftmost 24 bits through implicit narrowing. The sign bit, originally the 8th bit in the int, becomes the MSB in the byte, influencing its interpretation. To unveil the unsigned value, a bitwise AND operation is necessary, effectively erasing the sign bits.

The above is the detailed content of Why does converting an int to a byte in Java result in a negative value, and how can we retrieve the original unsigned value?. For more information, please follow other related articles on the PHP Chinese website!