Increment Operators: i++ and ++i

The increment operators are used to increase the value of a variable by 1. Their behavior differs based on placement.

Postfix Increment (i++):

• Returns the variable's original value first, then increments the variable by 1.
• When used as a standalone statement, it modifies the value without being part of an expression.

Prefix Increment (++i):

• Increments the variable's value by 1 first, then returns the new value.
• As a standalone statement, it modifies the value and the incremented value is used if the expression returns a result.

Code Demonstration

int counter = 5;

// Postfix increment
int postResult = counter++; // postResult = 5, counter = 6
System.out.println("PostResult: " + postResult);
System.out.println("Counter after postfix: " + counter);

// Prefix increment
int preResult = ++counter; // counter = 7, preResult = 7
System.out.println("PreResult: " + preResult);
System.out.println("Counter after prefix: " + counter);

Important Notes

• In loop constructs like for, both operators increment the variable, but timing affects when the increment occurs relative to loop body execution.
• Within expressions, ++i prvoides the updated value immediately, while i++ supplies the previous value.
• Modern compilers often opitmize both forms similarly for performance, though their logical sequencing remains distinct.

Bitwise AND (&) vs Logical AND (&&)

Bitwise AND (&):

• Performs AND operation on corresponding bits of two integer operands.
• Used for low-level bit manipulation, such as masking or clearing specific bits.

int firstVal = 0b1010; // Decimal 10
int secondVal = 0b1100; // Decimal 12
int bitwiseResult = firstVal & secondVal; // Result: 0b1000 (8)
System.out.println(Integer.toBinaryString(bitwiseResult)); // Prints: 1000

Logical AND (&&):

• Evaluates boolean expressions, returning true only if both operand are true.
• Features short-circuit evaluation: if the first operand is false, the second is not evaluated.

boolean flagA = true;
boolean flagB = false;
boolean logicalResult = flagA && flagB; // false
System.out.println(logicalResult);

// Short-circuit example
boolean safeCheck = (flagB && performExpensiveOperation()); // performExpensiveOperation() is not called

Usage Guidelines

• Apply & for integer bit-level operations.
• Use && for boolean logic in conditional statements to leverage short-circuiting and avoid unnecessary computations.

Bitwise OR (|) vs Logical OR (||)

Bitwise OR (|):

• Conducts OR operation on each bit pair of integer values.
• Commonly used to set specific bits within an integer.

int val1 = 0b1010; // 10
int val2 = 0b1100; // 12
int bitwiseOrResult = val1 | val2; // 0b1110 (14)
System.out.println(Integer.toBinaryString(bitwiseOrResult));

Logical OR (||):

• Returns true if at least one boolean operand is true.
• Also short-circuits; if the first operand is true, the second is skipped.

boolean cond1 = true;
boolean cond2 = false;
boolean logicalOrResult = cond1 || cond2; // true
System.out.println(logicalOrResult);

// Short-circuit example
boolean quickCheck = (cond1 || invokeRoutine()); // invokeRoutine() is bypassed

Application Scenarios

• Choose | for manipulating bits in numeric data.
• Opt for || when evaluating boolean conditions where short-circuiting can improve efficiency or safety.

Greater Than (>) vs Arithmetic Right Shift (>>)

Greater Than (>):

• A relational operator comparing two numeric values.
• Returns true if the left operand exceeds the right operand.

int numX = 15;
int numY = 25;
boolean isGreater = numX > numY; // false
System.out.println("Is X greater than Y? " + isGreater);

Arithmetic Right Shift (>>):

• Shifts bits of an integer right by a specified number of positions.
• Preserves the sign bit (fills leftmost bits with the sign bit: 0 for positive, 1 for negative).
• Equivalent to integer division by powers of two.

int value = 20; // Binary: 10100
int shiftedRight = value >> 2; // Result 5 (binary 101)
System.out.println("After shifting right twice: " + shiftedRight);

// With negative number
int negativeVal = -16;
int resultNeg = negativeVal >> 2; // Result -4 (sign preserved)
System.out.println("Negative shift result: " + resultNeg);

Logical Right Shift (>>>):

• Similar to >>, but always fills leftmost bits with zeros, treating the value as unsigned.
• Useful for processing bits without regard to sign.

int sample = -10;
int logicalShiftResult = sample >>> 1; // Fills with 0, result is a large positive number
System.out.println("Logical right shift: " + logicalShiftResult);

When to Use

• Employ > for comparisons in control structures like loops or conditional branches.
• Use >> for signed integer division by powers of two or bit-level data processing.
• Apply >>> when treating integers as unsigned bit patterns.