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
- The & operator always evaluates both expressions, whereas the && operator evaluates the second expression only if the first one is true
- & 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.