Difference between & and && in Java

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

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.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Comments

Spring Boot 3 Paid Course Published for Free
on my Java Guides YouTube Channel

Subscribe to my YouTube Channel (165K+ subscribers):
Java Guides Channel

Top 10 My Udemy Courses with Huge Discount:
Udemy Courses - Ramesh Fadatare