Difference between & and && in Java?

java

logical-operations

performance-optimization

best-practices

byAlex Kataev·Oct 2, 2024

& is a bitwise AND operator applicable on integers or a non-short-circuit logical AND operator for booleans, which always evaluates both operands. However, && is a logical AND operator that uses short-circuiting, meaning it stops once the first boolean operand turns out to be false, improving code efficiency.

Example:

// Let's see what bitwise AND does:
int result = 5 & 3; // You can't hide, 1 is here!

// Logical AND gives up at first sight of falsehood
boolean shortCircuitResult = (false) && (true); // "false detected, run for your life!"

Crux:

& wants to evaluate both parties, perfect for bitwise gymnastics and for boolean parties where everyone must attend.
&& is the pickier one, it only calls the second once the first shows its true colors. Optimal for boolean get-togethers.

A closer look

Efficiency disciples: bow down to `&&`

When it comes to condensed logic, && has got you covered. It does a run-and-done. If it sees false on the left-side, it won't even bother with the right-side. This comes in handy more often than you'd think, like with null checks:

if (object != null && object.isReady()) { ... }

With && in command, a NullPointerException has no chance! If object is null, object.isReady() gets a day off. Within control structures, you can count on && for performance and safety alignment.

Binary world and `&`

& loves to play at binary level. When you're dealing with binary data, you'll want & on your team:

int flagSet = 0b1010;
int mask = 0b1001;
int result = flagSet & mask;  // result is 0b1000

For anything bit-related—whether it's checking flags or masking—the full evaluation feature of & is your knight in shining armor.

Watch out: logic anomalies awaited

The misuse of these operators can give birth to logic errors. Suppose a boolean method needs both expressions to execute for a side effect:

if (methodWithSideEffect1() & methodWithSideEffect2()) { ... } // "Let both sides speak!"

With &&, methodWithSideEffect1() returning false is enough to shut methodWithSideEffect2() down. This might not match the method's original spirit intent, so contextual knowledge is key.

Exploring data types

Integer and boolean operations with `&`

& is that friend who's up for integer and boolean hangouts:

boolean bothTrue = true & false; // "Hmm, let's see, nope, false.";
int mixedBitwise = 0xFF00 & 0x00FF; // "Well, would you look at that! It's zero!";

With integers, & takes you on a bit-twisting adventure. With booleans, it makes sure to bring everyone to the party.

Logical operations gold rush with `&&`

&& can turn a coal mine into a gold rush, optimizing logical expressions in one sweep:

for (ComplexObject item : collection) {
    if (item.isAvailable() && item.matchesCriteria(...)) {
        // Popeye: Performance is my spinach!
    }
}

Result: drastic performance improvements, especially if matchesCriteria mocks a tortoise during an F1 race.

A developer's takeaways

Craft accurate and efficient code

Know your code's appetite. Are you going for full evaluations or have a soft spot for conditional short-circuit? & and && wield different weapons but won the same war: providing you with efficient and bullseye code.

Code clarity: no compromise

In boolean expressions, && takes the cake for clearer intent and readability. It's like an honest billboard — you're judging conditions, not juggling bits.