**I just announced the new *** Learn Spring * course, focused on the fundamentals of Spring 5 and Spring Boot 2:

*Learn Spring*course, focused on the fundamentals of Spring 5 and Spring Boot 2:

**>> CHECK OUT THE COURSE**

Last modified: December 25, 2019

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.

**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);

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);

**Like &, the logical AND (&&) operator compares the value of two boolean variables or expressions. **And, it returns also

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);

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

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);

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;

- 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

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.