I know the rules for `&&`

and `||`

but what are `&`

and `|`

? Please explain these to me with an example.

Those are the bitwise AND and bitwise OR operators.

```
int a = 6; // 110
int b = 4; // 100
// Bitwise AND
int c = a & b;
// 110
// & 100
// -----
// 100
// Bitwise OR
int d = a | b;
// 110
// | 100
// -----
// 110
System.out.println(c); // 4
System.out.println(d); // 6
```

Thanks to Carlos for pointing out the appropriate section in the Java Language Spec (15.22.1, 15.22.2) regarding the different behaviors of the operator based on its inputs.

Indeed when both inputs are boolean, the operators are considered the Boolean Logical Operators and behave similar to the Conditional-And (`&&`

) and Conditional-Or (`||`

) operators except for the fact that they don’t short-circuit so while the following is safe:

```
if((a != null) && (a.something == 3)){
}
```

This is not:

```
if((a != null) & (a.something == 3)){
}
```

I think you’re talking about the logical meaning of both operators, here you have a table-resume:

```
boolean a, b;
Operation Meaning Note
--------- ------- ----
a && b logical AND short-circuiting
a || b logical OR short-circuiting
a & b boolean logical AND not short-circuiting
a | b boolean logical OR not short-circuiting
a ^ b boolean logical exclusive OR
!a logical NOT
short-circuiting (x != 0) && (1/x > 1) SAFE
not short-circuiting (x != 0) & (1/x > 1) NOT SAFE
```

I know there’s a lot of answers here, but they all seem a bit confusing. So after doing some research from the Java oracle study guide, I’ve come up with three different scenarios of when to use && or &.

The three scenarios are **logical AND**, **bitwise AND**, and **boolean AND**.

**Logical AND:**

Logical AND (aka Conditional AND) uses the **&&** operator. It’s short-circuited meaning: if the left operand is false, then the right operand will not be evaluated.

Example:

```
int x = 0;
if (false && (1 == ++x) {
System.out.println("Inside of if");
}
System.out.println(x); // "0"
```

In the above example the value printed to the console of x will be 0, because the first operand in the if statement is false, hence java has no need to compute (1 == ++x) therefore x will not be computed.

**Bitwise AND:**

Bitwise AND uses the **&** operator. It’s used to preform a bitwise operation on the value. It’s much easier to see what’s going on by looking at operation on binary numbers ex:

```
int a = 5; // 5 in binary is 0101
int b = 12; // 12 in binary is 1100
int c = a & b; // bitwise & preformed on a and b is 0100 which is 4
```

As you can see in the example, when the binary representations of the numbers 5 and 12 are lined up, then a bitwise AND preformed will only produce a binary number where the same digit in both numbers have a 1. Hence 0101 & 1100 == 0100. Which in decimal is 5 & 12 == 4.

**Boolean AND:**

Now the boolean AND operator behaves similarly and differently to both the bitwise AND and logical AND. I like to think of it as preforming a bitwise AND between two boolean values (or bits), therefore it uses **&** operator. The boolean values can be the result of a logical expression too.

It returns either a true or false value, much like the logical AND, but unlike the logical AND it is not short-circuited. The reason being, is that for it to preform that bitwise AND, it must know the value of both left and right operands. Here’s an ex:

```
int x = 0;
if (false & (1 == ++x) {
System.out.println("Inside of if");
}
System.out.println(x); //"1"
```

Now when that if statement is ran, the expression (1 == ++x) will be executed, even though the left operand is false. Hence the value printed out for x will be 1 because it got incremented.

This also applies to Logical OR (||), bitwise OR (|), and boolean OR (|)

Hope this clears up some confusion.

The operators && and || are short-circuiting, meaning they will not evaluate their right-hand expression if the value of the left-hand expression is enough to determine the result.

& and | provide the same outcome as the && and || operators. The difference is that they always evaluate both sides of the expression where as && and || stop evaluating if the first condition is enough to determine the outcome.

`&`

and `|`

are bitwise operators on integral types (e.g. `int`

): http://download.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

`&&`

and `||`

operate on booleans only (and short-circuit, as other answers have already said).

In Java, the single operators &, |, ^, ! depend on the operands. If both operands are ints, then a bitwise operation is performed. If both are booleans, a “logical” operation is performed.

If both operands mismatch, a compile time error is thrown.

The double operators &&, || behave similarly to their single counterparts, but both operands must be conditional expressions, for example:

if (( a < 0 ) && ( b < 0 )) { … } or similarly,

if (( a < 0 ) || ( b < 0 )) { … }

source: java programming lang 4th ed

Maybe it can be useful to know that the bitwise AND and bitwise OR operators are always evaluated before conditional AND and conditional OR used in the same expression.

```
if ( (1>2) && (2>1) | true) // false!
```

&& ; || are logical operators…. short circuit

& ; | are boolean logical operators…. Non-short circuit

Moving to differences in execution on expressions. Bitwise operators evaluate both sides irrespective of the result of left hand side. But in the case of evaluating expressions with logical operators, the evaluation of the right hand expression is dependent on the left hand condition.

For Example:

```
int i = 25;
int j = 25;
if(i++ < 0 && j++ > 0)
System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);
```

This will print i=26 ; j=25, As the first condition is false the right hand condition is bypassed as the result is false anyways irrespective of the right hand side condition.(short circuit)

```
int i = 25;
int j = 25;
if(i++ < 0 & j++ > 0)
System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);
```

But, this will print i=26; j=26,

If an expression involving the Boolean **&** operator is evaluated, both operands are evaluated. Then the & operator is applied to the operand.

When an expression involving the **&&** operator is evaluated, the first operand is evaluated. If the first operand evaluates to false, the evaluation of the second operand is skipped.

If the first operand returns a value of true then the second operand is evaluated. If the second operand returns a value of true then && operator is then applied to the first and second operands.

Similar for | and ||.

While the basic difference is that `&`

is used for bitwise operations mostly on `long`

, `int`

or `byte`

where it can be used for kind of a mask, the results can differ even if you use it instead of logical `&&`

.

The difference is more noticeable in some scenarios:

- Evaluating some of the expressions is time consuming
- Evaluating one of the expression can be done only if the previous one was true
- The expressions have some side-effect (intended or not)

First point is quite straightforward, it causes no bugs, but it takes more time. If you have several different checks in one conditional statements, put those that are either cheaper or more likely to fail to the left.

For second point, see this example:

```
if ((a != null) & (a.isEmpty()))
```

This fails for `null`

, as evaluating the second expression produces a `NullPointerException`

. Logical operator `&&`

is lazy, if left operand is false, the result is false no matter what right operand is.

Example for the third point — let’s say we have an app that uses DB without any triggers or cascades. Before we remove a Building object, we must change a Department object’s building to another one. Let’s also say the operation status is returned as a boolean (true = success). Then:

```
if (departmentDao.update(department, newBuilding) & buildingDao.remove(building))
```

This evaluates both expressions and thus performs building removal even if the department update failed for some reason. With `&&`

, it works as intended and it stops after first failure.

As for `a || b`

, it is equivalent of `!(!a && !b)`

, it stops if `a`

is true, no more explanation needed.