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