1. Overview
In this tutorial, we’ll look at how to implement low-level bitmasking using bitwise operators. We’ll see how we can treat a single int variable as a container for a separate piece of data, similar to BitSet.
2. Bitmasking
Bitmasking allows us to store multiple values inside one numerical variable. Instead of thinking about this variable as a whole number, we treat its every bit as a separate value.
Because a bit can equal either zero or one, we can also think of it as either false or true. We can also slice a group of bits and treat them as a smaller number variable or even a String.
2.1. Example
Suppose we have a minimal memory footprint and need to store all information about a user’s account inside one int variable. The first eight bits (from 32 available) will store boolean information like “is the account active?” or “is the account premium?”
As for the remaining 24 bits, we’ll convert them to three characters that will serve as the user’s identifier.
2.2. Encoding
Our user will have an identifier “AAA”, and he’ll have an active and premium account (stored in the first two bits). In binary representation, it will look like:
String stringRepresentation = "01000001010000010100000100000011";
This can be easily encoded into an int variable using the built-in Integer#parseUnsignedInt method:
int intRepresentation = Integer.parseUnsignedInt(stringRepresentation, 2);
assertEquals(intRepresentation, 1094795523);
2.3. Decoding
This process can also be reversed using the Integer#toBinaryString method:
String binaryString = Integer.toBinaryString(intRepresentation);
String stringRepresentation = padWithZeros(binaryString);
assertEquals(stringRepresentation, "01000001010000010100000100000011");
3. Extracting One Bit
3.1. First Bit
If we want to check the first bit of our account variable, all we need is the bitwise “and” operator and the number “one“ as a bitmask. Because number “one” in binary form has only the first bit set to one and the rest of them are zeros, it will erase all the bits from our variable, leaving only the first one intact:
10000010100000101000001000000011
00000000000000000000000000000001
-------------------------------- &
00000000000000000000000000000001
Then we need to check if the produced value is not equal to zero:
intRepresentation & 1 != 0
3.2. Bit at Arbitrary Position
If we want to check some other bit, we need to create an appropriate mask, which needs to have a bit at the given position set to one and the rest set to zeros. The easiest way to do that is to shift the mask we already have:
1 << (position - 1)
The above line of code with the position variable set to 3 will change our mask from:
00000000000000000000000000000001
to:
00000000000000000000000000000100
So now, the bitwise equation will look like this:
10000010100000101000001000000011
00000000000000000000000000000100
-------------------------------- &
00000000000000000000000000000000
Putting all of this together, we can write a method for extracting a single bit at the given position:
private boolean extractValueAtPosition(int intRepresentation, int position) {
return ((intRepresentation) & (1 << (position - 1))) != 0;
}
To the same effect, we could also shift the intRepresentation variable in the reverse direction instead of changing the mask.
4. Extracting Multiple Bits
We can use similar methods to extract multiple bits from an integer. Let’s extract the last three bytes of our user account variable and convert them into a string. First, we need to get rid of the first eight bits by shifting the variable to the right:
int lastThreeBites = intRepresentation >> 8;
String stringRepresentation = getStringRepresentation(lastThreeBites);
assertEquals(stringRepresentation, "00000000010000010100000101000001");
We still have 32 bits because the int will always have 32 bits. However, now we’re interested in the first 24 bits, and the rest of them are zeros and will be easy to ignore. The int variable we created could be easily used as an integer ID, but because we want to have a string ID, we have one more step to do.
We’ll split the string representation of the binary into groups of eight characters, parse them to char variables, and join them into one final String.
For convenience, we’ll also ignore empty bytes:
Arrays.stream(stringRepresentation.split("(?<=\\G.{8})"))
.filter(eightBits -> !eightBits.equals("00000000"))
.map(eightBits -> (char)Integer.parseInt(eightBits, 2))
.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
.toString();
5. Applying a Bitmask
Instead of extracting and checking values of single bits, we can also create a mask to check many of them at the same time. We want to check if our user has an active and premium account, so his variable has the first two bits both set to one.
We could check them separately using previous methods, but it’s faster to create a mask that will select them both:
int user = Integer.parseUnsignedInt("00000000010000010100000101000001", 2);
int mask = Integer.parseUnsignedInt("00000000000000000000000000000011", 2);
int masked = user & mask;
Because our user has an active account, but it’s not premium, the masked value will have only the first bit set to one:
assertEquals(getStringRepresentation(masked), "00000000000000000000000000000001");
Now, we can easily and cheaply assert whether a user meets our conditions:
assertFalse((user & mask) == mask);
6. Conclusion
In this tutorial, we learned how to use bitwise operators to create bitmasks and apply them to extract binary information from integers. As always, all the code examples are available over on GitHub.
