G.4 Representing Integers

Integer data types in Java represent signed integer values, that is, both positive and negative integer values. The values of char type can effectively be regarded as unsigned 16-bit integers.

Values of type byte are represented as shown in Table G.2. A value of type byte requires 8 bits. With 8 bits, we can represent 2⁸ or 256 values. Java uses 2's complement (explained later) to store signed values of integer data types. For the byte data type, this means values are in the range ?128 (?2⁷) to +127 (2⁷?1), inclusive.

Bits in an integral value are usually numbered from right to left, starting with the least significant bit 0 (also called the right-most bit). When applying bitwise operators, the number of the most significant bit (also called the left-most bit) is dependent on the integral type; bit 31 for byte, short, char, and int, and bit 63 for long. The representation of the signed types sets the most significant bit to 1, indicating negative values. Adding 1 to the maximum int value 2147483647 results in the minimum value -2147483648, that is, the values wrap around for integers and no overflow or underflow is indicated.

Calculating 2's Complement

Before we look at 2's complement, we need to understand 1's complement. 1's complement of a binary integer is computed by inverting the bits in the number. Thus, 1's complement of the binary number 00101001 is 11010110. 1's complement of a binary number N₂ is denoted as ~N₂. The following relations hold between a binary integer N₂, its 1's complement ~N₂, and its 2's complement ?N₂:

?N₂ = ~N₂ + 1
  0 = ?N₂ + N₂

If N₂ is a positive binary integer, then ?N₂ denotes its negative binary value, and vice versa. The second relation states that adding a binary integer N₂ to its 2's complement ?N₂ equals 0.

Given a positive byte value, say 41, the binary representation of -41 can be found as follows:

Similarly, given a negative number, say -41, we can find the binary representation of 41:

Adding a number N₂ to its 2's complement ?N₂ gives 0, and the carry bit from the addition of the most significant bits (after any necessary extension of the operands) is ignored:

Subtraction between two integers is also computed as addition with 2's complement:

N₂ ? M₂ = N₂ + (?M₂)

For example, calculating 41₁₀ ? 3₁₀ (with the correct result 38₁₀) is computed as follows:

The previous discussion on byte values applies equally to values of other integer types: short, int, and long. These types have their values represented by 2's complement in 16, 32, and 64 bits, respectively.