Java IO.pdf - Nguyen Dang Binh

int unsignedByte = signedByte >= 0 ? signedByte : 256 + signedByte;
1.2.2 Conversions and Casts
Java I/O
Since bytes have such a small range, they're often converted to ints in calculations and
method invocations. Often they need to be converted back, generally through a cast.
Therefore, it's useful to have a good grasp of exactly how the conversion occurs.
Casting from an int to a byte—for that matter, casting from any wider integer type to a
narrower type—takes place through truncation of the high-order bytes. This means that as
long as the value of the wider type can be expressed in the narrower type, the value is not
changed. The int 127 cast to a byte still retains the value 127.
On the other hand, if the int value is too large for a byte, strange things happen. The int 128
cast to a byte is not 127, the nearest byte value. Instead, it is -128. This occurs through the
wonders of two's complement arithmetic. Written in hexadecimal, 128 is 0x00000080. When
that int is cast to a byte, the leading zeros are truncated, leaving 0x80. In binary this can be
written as 10000000. If this were an unsigned number, 10000000 would be 128 and all would
be fine, but this isn't an unsigned number. Instead, the leading bit is a sign bit, and that 1 does
not indicate 2 7 but a minus sign. The absolute value of a negative number is found by taking
the complement (changing all the 1 bits to bits and vice versa) and adding 1. The complement
of 10000000 is 01111111. Adding 1, you have 01111111 + 1 = 10000000 = 128 (decimal).
Therefore, the byte 0x80 actually represents -128. Similar calculations show that the int 129
is cast to the byte -127, the int 130 is cast to the byte -126, the int 131 is cast to the byte -
125, and so on. This continues through the int 255, which is cast to the byte -1.
When 256 is reached, the low-order bytes of the int are now filled with zeros. In other words,
256 is 0x00000100. Thus casting it to a byte produces 0, and the cycle starts over. This
behavior can be reproduced algorithmically with this formula, though a cast is obviously
simpler:
int byteValue;
int temp = intValue % 256;
if ( intValue < 0) {
byteValue = temp < -128 ? 256 + temp : temp;
}
else {
byteValue = temp > 127 ? temp - 256 : temp;
}
1.3 Character Data
Numbers are only part of the data a typical Java program needs to read and write. Most
programs also need to handle text, which is composed of characters. Since computers only
really understand numbers, characters are encoded by matching each character in a given
script to a particular number. For example, in the common ASCII encoding, the character A is
mapped to the number 65; the character B is mapped to the number 66; the character C is
mapped to the number 67; and so on. Different encodings may encode different scripts or may
encode the same or similar scripts in different ways.
20