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

res – REST with Spring (eBook) (everywhere)