Bitwise & vs Logical && Operators

1. Introduction

In Java, we've got two ways to say “AND”. But which to use?

In this tutorial, we'll look at the differences between & and &&. And, we'll learn about bitwise operations and short-circuiting along the way.

2. Use of Bitwise AND

The bitwise AND (&) operator compares each binary digit of two integers and returns 1 if both are 1, otherwise, it returns 0. 

Let's take a look at two integers:

int six = 6;
int five = 5;

Next, let's apply a bitwise AND operator on these numbers:

int resultShouldBeFour = six & five;
assertEquals(4, resultShouldBeFour);

To understand this operation, let's look at the binary representation of each number:

Binary of decimal 4: 0100
Binary of decimal 5: 0101
Binary of decimal 6: 0110

The & operator performs a logical AND on each bit, and returns a new binary number:

0110
0101
-----
0100

Finally, our result –  0100 – can be converted back to decimal number – 4.

Let's see the test Java code:

int six = 6;
int five = 5;
int resultShouldBeFour = six & five;
assertEquals(4, resultShouldBeFour);

2.1. Use of & with Booleans

Also, we can use the bitwise AND (&) operator with boolean operands. It returns true only if both the operands are true, otherwise, it returns false.

Let's take three boolean variables:

boolean trueBool = true;
boolean anotherTrueBool = true;
boolean falseBool = false;

Next, let's apply a bitwise AND operator on variables trueBool and anotherTrueBool:

boolean trueANDtrue = trueBool & anotherTrueBool;

Then, the result will be true.

Next, let's apply a bitwise AND operator on trueBool and falseBool:

boolean trueANDFalse = trueBool & falseBool;

In this case, the result will be false.

Let's see the test Java code:

boolean trueBool = true;
boolean anotherTrueBool = true;
boolean falseBool = false;

boolean trueANDtrue= trueBool & anotherTrueBool;
boolean trueANDFalse = trueBool & falseBool;

assertTrue(trueANDtrue);
assertFalse(trueANDFalse);

3. Use of Logical AND

Like &, the logical AND (&&) operator compares the value of two boolean variables or expressions. And, it returns also true only if both operands are true, otherwise, it returns false.

Let's take three boolean variables:

boolean trueBool = true;
boolean anotherTrueBool = true;
boolean falseBool = false;

Next, let's apply a logical AND operator on variables trueBool and anotherTrueBool:

boolean trueANDtrue = trueBool && anotherTrueBool;

Then, the result will be true.

Next, let's apply a logical AND operator on trueBool and falseBool:

boolean trueANDFalse = trueBool && falseBool;

In this case, the result will be false.

Let's see the test Java code:

boolean trueBool = true;
boolean anotherTrueBool = true;
boolean falseBool = false;
boolean anotherFalseBool = false;

boolean trueANDtrue = trueBool && anotherTrueBool;
boolean trueANDFalse = trueBool && falseBool;
boolean falseANDFalse = falseBool && anotherFalseBool;

assertTrue(trueANDtrue);
assertFalse(trueANDFalse);
assertFalse(falseANDFalse);

3.1. Short-circuit

So, what's the difference? Well, the && operator short-circuits. This means it doesn't evaluate the right-hand side operand or expression when the left-hand side operand or expression is false.

Let's take two expressions evaluating as false:

First Expression: 2<1
Second Expression: 4<5

When we apply a logical AND operator on expressions 2<1 and 4<5, then it evaluates only the first expression 2<1 and returns false.

boolean shortCircuitResult = (2<1) && (4<5);
assertFalse(shortCircuitResult);

3.2. Use of && with Integers

We can use the & operator with boolean or numeric types but && can only be used with boolean operands. Using it with integer operands results in a compilation error:

int five = 2;
int six = 4;
int result = five && six;

4. Comparison

1. The & operator always evaluates both expressions, whereas the && operator evaluates the second expression only if the first one is true
2. & compares each operand bitwise, whereas && operates only on booleans

5. Conclusion

In this article, we used the bitwise & operator to compare bits of two digits resulting in a new digit. Also, we used the logical && operator to compare two booleans, resulting in a boolean value.

We also saw some key differences between the two operators.

As always you can find the code for this tutorial over on GitHub.