Representation of Integers at a Bit Level in Java

2. Bitwise Operations in Java

In Java, integers are represented using 32 bits, and long integers use 64 bits. It’s important to note that Java uses 2’s complement representation for negative numbers. In this case, where the first bit is 1, the number is assumed to be negative. Negative numbers are calculated by taking the number, flipping all 1’s and 0’s, and then adding 1.

For example, in eight bits, the number 6 is 0b00000110. To convert this to -6, we invert it to 0b11111001 and then, add one, so it becomes 0b11111010.

Furthermore, bitwise operations lay a great foundation for several use cases as they are often quicker for the CPU that full mathematical or logical expressions.

2.1. AND Operator (&)

The AND operator (&) performs a bitwise AND operation between two 32-bit integers:

int result = 0b1100 & 0b0111;
assertEquals(0b0100, result);

This operation evaluates each bit’s position independently. If both corresponding bits in the operands are 1, the result will have a 1 at that position; otherwise, it will be 0. In the provided example:

• Binary representation of 12 (0b1100)
• Binary representation of 7 (0b0111)
• Bitwise AND operation yields 0b0100
• Resulting in the decimal value 4

2.2. OR Operator (|)

The OR operator (|) does a bitwise OR operation on the same-position bits of two numbers:

int result = 0b1100 | 0b0111;
assertEquals(0b1111, result);

Similar to the AND operator, the OR operator compares each bit position. If at least one of the corresponding bits in the operands is 1, the result will have a 1 at that position. In this example, the result is 0b1111, equivalent to the decimal value 15.

2.3. XOR Operator (^)

We can use the XOR operator (^) in a bitwise XOR operation in which the corresponding bits are operated on each other:

int result = 0b1100 ^ 0b0111;
assertEquals(0b1011, result);

This operation sets the result bit to 1 if the corresponding bits in the operands differ. In the provided example, the result is 0b1011, corresponding to the decimal value 11.

2.4. Bitwise NOT (~)

The bitwise NOT operator (~) inverts the bits of its operand, turning 1s into 0s and vice versa:

int result = ~0b0101;
assertEquals(-0b0110, result);

Each bit is inverted, transforming 0s into 1s and vice versa. Moreover, the result is -0b0110, equivalent to the decimal value -6 using two’s complement representation.

2.5. Left Shift (<<) and Right Shift (>>)

The left shift (<<) operator shifts the bits of a number to the left by a specified number of positions:

int result = 0b0101 << 2;
assertEquals(0b10100, result);

Here, we perform a bitwise left shift operation on the value stored in variable a. Furthermore, this operation shifts the binary representation of two positions to the left, padding the vacated positions on the right with zeros.

Similarly, the right shift (>>) operator shifts the bits to the right:

int result = 0b0101 >> 1;
assertEquals(0b10, result);

Conversely, we perform a bitwise right shift operation by shifting the binary representation of the variable a one position to the right. The vacated position on the left is filled based on the sign bit for signed integers. So positive numbers stay positive and negative numbers stay negative.

3. Use Case: Color Modification Using Bitwise Operations

In this practical example, we’ll explore how we can apply bitwise operations to modify the color of an RGB value.

3.1. Original Colors and Masks

int originalColor = 0xFF336699;
int alphaMask = 0xFF000000;
int redMask = 0x00FF0000;
int greenMask = 0x0000FF00;
int blueMask = 0x000000FF;

Here, we initialize the original color as 0xFF336699, a hexadecimal representation of an RGB color. Additionally, four masks (alphaMask, redMask, greenMask, and blueMask) are defined to extract individual color components based on their bit positions.

We extract the alpha, red, green, and blue components using bitwise AND operations with their respective masks. Then, we apply the right shift (>>>) to align the extracted bits to the least significant bit (LSB) position.

• The alpha component, extracted by (originalColor & alphaMask) >>> 24, results in 1111 1111 in binary
• The red component, extracted by (originalColor & redMask) >>> 16, is 0011 0011 in binary
• The green component, extracted by (originalColor & greenMask) >>> 8, is 0110 1001 in binary
• The blue component, extracted by originalColor & blueMask, is 1001 1001 in binary

3.3. Modifying Color Components

red = Math.min(255, red + 50);
green = Math.min(255, green + 30);

Next, we modified the red and green components, simulating a color adjustment. Moreover, we perform the modification while ensuring that the values don’t exceed the maximum of 255.

• The red component is modified using red = Math.min(255, red + 50), resulting in 0100 0010 in binary
• The green component is modified using green = Math.min(255, green + 30), resulting in 0111 1111 in binary

3.4. Recreating Modified Color

int modifiedColor = (alpha << 24) | (red << 16) | (green << 8) | blue;

Furthermore, we combine the modified alpha, red, green, and blue components using bitwise OR (|) and left shift (<<) operations to recreate the modified color.

The reconstructed color is calculated as modifiedColor = (alpha << 24) | (red << 16) | (green << 8) | blue, resulting in 1111 1111 0010 0010 1101 0110 1001 in binary.

4. Conclusion

In this article we looked at how Java represents numbers in memory. We looked at the binary representation and how to use it to understand bitwise operations.

Finally, we looked at a way that masks and bit shifting can be useful in a real-world example.

As always, the complete code samples for this article can be found over on GitHub.