Bitwise operators seem obscure but are quite useful once mastered! This comprehensive guide will explain bitwise operators in Java through practical examples you can apply immediately.
I‘ll cover what bitwise operators are, when to use them, walk through examples of each operator, and address common mistakes. You‘ll gain the knowledge to read and write performant bit-twiddling code!
Why Learn Bitwise Operators?
Bitwise operators manipulate numbers at the binary level – they directly control the 1‘s and 0‘s representing data.
You may be wondering:
- Why work directly with bits? Can‘t I just use normal math?
- When would I ever need to flip individual bits?
Excellent questions! Here are 3 key reasons to learn bitwise operators:
- Improved performance: Bitwise operators are faster for low-level tasks
- Fine-grained control: Directly set, toggle, test individual bits
- Optimize space: Pack flags and small values into a single 32 bit integer
While modern languages abstract these details away, understanding bit manipulation helps write optimized systems code.
Let‘s look at some common scenarios where bitwise operators shine…
Logical Flags & Bitmasks
Applications often use logical flags to encode options – "User has permission to read / write / delete".
We can store these directly as boolean values, but that consumes space.
Instead, each flag can be assigned one bit in an integer. Bitwise OR sets flags, AND tests flags, XOR and shifts toggle them.
This technique is very common when memory or network bandwidth is limited.
Here‘s an example 7-bit permission bitmask:
Permission Types:
Read : Bit 0
Write : Bit 1
Delete : Bit 2
Execute : Bit 3
Administer : Bit 4To test if "Read" permission is set:
if ((mask & 0b00000001) != 0) {
// Has read permission
}Efficient Multiplication & Division
Bit shifts can multiply or divide integers by powers of two very efficiently.
This is much faster than using typical math operators:
int x = 5;
x << 3; // Same as x * 2^3 = 5 * 8 = 40
int y = 100;
y >> 2; // Same as y / 2^2 = 100 / 4 = 25Programmers leverage this for optimizations in critical loops and algorithms.
Onto some concrete examples!
Bitwise AND Operator (&)
The AND operator performs a bit-by-bit AND between two values. Performs AND between corresponding bits of the operands.
If both bits are 1, the result is 1. Otherwise, the result is 0.
First Operand: 0110 0111
Second Operand: 0101 0101
--------
Result (AND): 0100 0101In Java:
int first = 103; // 0110 0111
int second = 85; // 0101 0101
int result = first & second; // 85 (0100 0101)Let‘s explore a common use case…
Flag/Bit Checking with AND
The AND operator can test if a specific bit is set.
For example, checking if bit 3 is 1:
// Flag word
int flags = 0b10110;
if ((flags & 0b1000) != 0) {
// Bit 3 is 1
System.out.println("Bit 3 set!");
} else {
// Bit 3 is not set
}
// Prints "Bit 3 Set!"The AND masks out (sets to 0) all bits other than the bit we are testing.
This technique is very commonly used on bitmasks as mentioned earlier.
Now let‘s look at the OR operator…
Bitwise OR Operator (|)
The OR operator performs a bitwise OR operation between two values, setting result bits to 1 if either input bit is 1.
If both input bits are 0, the result is 0. Otherwise, the result is 1.
First operand: 0110 0111
Second operand: 0101 0101
--------
Result (OR): 0111 0111Here‘s the OR operator in Java:
int first = 103; // 0110 0111
int second = 85; // 0101 0101
int result = first | second; // 119 (0111 0111) The OR operator is handy for setting flags/bits to 1 without affecting existing set bits.
Let‘s walk through an example…
Setting Flags with OR
We can use OR to set flags in a bitmask variable:
// Permission bitflags
int perms = 0b0001; // Read permission
// Set write permission
perms = perms | 0b0010;
// perms now equals 3 (0b0011)
// - Read flag preserved from earlier
// - Write flag set via ORAnd there you have it! With OR, we enabled a new permission while keeping existing permissions active.
Now, let‘s shift our focus to the exclusive OR operator…
Bitwise XOR Operator (^)
The XOR (exclusive OR) operator toggles result bits to 1 if only one corresponding input bit is 1.
If both input bits are 0 or 1, the result is set to 0. Hence the name "exclusive".
First operand: 0110 0111
Second operand: 0101 0101
--------
Result (XOR): 0011 0010Here is the XOR operator in a Java example:
int first = 103; // 0110 0111
int second = 85; // 0101 0101
int result = first ^ second; // 50 (0011 0010)The interesting behaviors of XOR lend it well to toggling bits. Let‘s see how…
Toggling Bits with XOR
To toggle a bit from 0 to 1, or 1 to 0 using XOR:
int toggler = 0b1000;
int bits = 0b1110;
bits ^= toggler;
// bits = 1110 XOR 1000
// 0110 = 14 in decimal The XOR operator flips bits set in the toggler, while preserving other bits.
This is very useful for changing flag values, enabling/disabling debug modes, and much more!
Next up: Bit shifts!
Bitwise Shift Operators
The left and right shift operators move all bits in a value by a specified number of positions.
Shifts are equivalent to multiplying or dividing an integer by a power of two.
Let‘s start with left shifts…
Left Shift Operator (<<)
The left shift operator (<<) shifts all bits to the left by a specified amount, adding 0‘s on the right.
Left shift multiplied the original value by 2 raised to the shift amount.
Shift left by 2 positions
Original: 0011 0100
After << 2: 1100 0100Equivalent to multiplying by 22 = 4:
int a = 50; // 0011 0100
int b = a << 2; // b = 200 (1100 1000)
// Same as a * 2^2
// Same as a * 4 This enables very fast multiplication by powers of two.
Now, let‘s check out right shifts…
Right Shift Operator (>>)
The right shift operator (>>) shifts all bits to the right by given amount, discarding bits shifted off:
Original: 0011 0010
>> 2
After >> 2: 0000 1100Right shift divides the original value by 2 raised to the shift amount:
int a = 50; // 0011 0010
int b = a >> 2; // b = 12 (0000 1100)
// Same as a / 4This allows efficiently dividing integers by powers of two.
And with that, you‘ve seen all the major Java bitwise operators! Let‘s recap…
Summary: Why and When to Use Bitwise Operators
We walked through all the key bitwise operators:
- AND, OR, XOR
- Bit shifts
- Bitmask manipulation examples
- Performance optimizations
To recap – use bitwise operators when:
- You need to directly control bits, for flags/options
- Greater speed for bit-level math
- Require bitmasking for permissions/flags
- Need optimized multiplication/division by powers of two
Understanding these basics empowers you to wield bits like a pro!
Now, time for some super important best practices…
Key Best Practices
While powerful, bitwise operators do have some pitfalls programmers encounter:
Prefer Higher-Level Abstractions
Resist the urge to use bit-twiddling all over your app! As a principle:
Favor higher-level abstractions > bitwise ops where feasible.
For example, sets and hash tables vs bitmasks for group membership.
Beware 32 Bit Limits!
Our integer word size limits how many flags and values we can pack:
0 to 31 bits per integer!
Running out causes messy overflows. Audit code for sufficient capacity.
Bitwise vs Logical Operators
Newcomers often mix up bitwise & logical operators. Key Difference:
- Bitwise AND/OR/XOR works on actual binary bits
- Logical AND/OR works on boolean true/false
int a = 5; // 0000 0101
int b = 3; // 0000 0011
a & b; // Bitwise AND -> 0000 0001
true && false; // Logical ANDAnd there you have it – hopefully you now feel empowered to hack bits with the best of them! Take these new skills and create something awesome. Happy coding!
John Doe
Senior Systems Architect, Acme Networks
