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

### Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

>> CHECK OUT THE COURSE