Representation of Integers at a Bit Level in Java

1. Overview

Java stores numbers in memory as binary. Understanding how integers are represented at the bit level can help us with certain operations.

In this tutorial, we’ll look at some of the specifics of number representation in Java, and see how Java’s bitwise operations work.

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 than 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.

3.2. Extracting Color Components

int alpha = (originalColor & alphaMask) >>> 24;
int red = (originalColor & redMask) >>> 16;
int green = (originalColor & greenMask) >>> 8;
int blue = originalColor & blueMask;

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

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