Difference between & and && in Java

1. Introduction

In Java, & and && are operators used for evaluating boolean expressions. The & operator is the bitwise AND operator when used with numbers and the logical AND operator when used with boolean values. The && operator is the short-circuit logical AND operator that evaluates boolean expressions only.

2. Key Points

1. & evaluates both sides of the operation regardless of the result of the first one when used as a logical AND operator.

2. && evaluates the second operand only if the first operand is true.

3. & is also a bitwise operator for integer types.

4. && provides performance benefits by not evaluating the right-hand side expression if it's not necessary.

3. Differences

& (AND)	&& (Short-circuit AND)
Always evaluates both operands.	Evaluates the second operand only if the first is true.
Can be used as both a bitwise and a logical operator.	Used only as a logical operator.
No performance optimization in Boolean expressions.	Can provide performance optimization in boolean expressions.

4. Example

public class AndOperators {
    public static void main(String[] args) {
        int a = 4; // 100 in binary
        int b = 5; // 101 in binary

        // Step 1: Using the bitwise AND operator
        int result = a & b; // This will be 100 in binary or 4 in decimal
        System.out.println("Bitwise AND result: " + result);

        // Step 2: Using the logical AND operator
        boolean firstCondition = true;
        boolean secondCondition = false;

        // The & operator evaluates both conditions
        if (firstCondition & secondCondition) {
            System.out.println("Both conditions are true.");
        } else {
            System.out.println("Using & operator: one or both conditions are false.");
        }

        // The && operator does not evaluate the second condition because the first is false
        if (firstCondition && secondCondition) {
            System.out.println("Both conditions are true.");
        } else {
            System.out.println("Using && operator: one or both conditions are false.");
        }
    }
}

Output:

Bitwise AND result: 4
Using & operator: one or both conditions are false.
Using && operator: one or both conditions are false.

Explanation:

1. The bitwise AND operation between a and b results in 4, as it operates on each bit of the integers.

2. The logical AND & checks both firstCondition and secondCondition even though it's clear that the combined expression cannot be true if the first condition is false.

3. The short-circuit AND && checks firstCondition, finds it to be true, and then checks secondCondition. Since secondCondition is false, it stops and returns false.

5. When to use?

- Use & as a bitwise operator when you're working with bits or as a logical operator when you need to evaluate both conditions for their side effects.

- Use && when evaluating boolean expressions where the second condition does not need to be evaluated if the first one is false, for performance reasons.