Operators

// 1. Arithmetic — math operations:
+  -  *  /  %  ++  --

// 2. Relational — comparisons that produce boolean:
==  !=  >  <  >=  <=

// 3. Logical — boolean logic:
&&  ||  !  ^

// 4. Bitwise — operate on individual bits:
&  |  ^  ~  <<  >>  >>>

// 5. Assignment — store values:
=  +=  -=  *=  /=  %=  &=  |=  ^=  <<=  >>=  >>>=

// 6. Unary — single operand:
+  -  ++  --  !  ~

// 7. Ternary — three-part conditional:
? :

// 8. instanceof — type checking:
instanceof

// Precedence table (highest to lowest):
//
// Level  Operator(s)                          Associativity
// ─────────────────────────────────────────────────────────
//  1     ()  []  .                            left → right
//  2     ++  -- (postfix)                     left → right
//  3     ++  -- (prefix)  +  - (unary)  ~  ! right → left
//  4     *  /  %                              left → right
//  5     +  -                                 left → right
//  6     <<  >>  >>>                          left → right
//  7     <  >  <=  >=  instanceof             left → right
//  8     ==  !=                               left → right
//  9     &                                    left → right
//  10    ^                                    left → right
//  11    |                                    left → right
//  12    &&                                   left → right
//  13    ||                                   left → right
//  14    ? :                                  right → left
//  15    =  +=  -=  *=  /=  etc.             right → left

// Examples:
int result = 2 + 3 * 4;       // 14 — * before +
int result2 = (2 + 3) * 4;    // 20 — () overrides precedence

boolean b = 5 > 3 && 2 < 4;   // true — > and < before &&
boolean b2 = true || false && false;  // true — && before ||

// Left-to-right associativity (most operators):
int result = 10 - 3 - 2;    // (10 - 3) - 2 = 5, not 10 - (3 - 2) = 9
int div = 24 / 4 / 2;       // (24 / 4) / 2 = 3

// Right-to-left associativity (assignment operators):
int a, b, c;
a = b = c = 10;   // evaluated as a = (b = (c = 10))
// c gets 10 first, then b gets 10, then a gets 10

// Right-to-left (prefix unary):
int x = 5;
int y = - -x;     // -(-5) = 5 — double negation

// Right-to-left (ternary):
int n = 5;
String s = n > 0 ? "positive" : n < 0 ? "negative" : "zero";
// evaluated as: n > 0 ? "positive" : (n < 0 ? "negative" : "zero")

// && short-circuits on first false:
String name = null;
if (name != null && name.length() > 0) {
    // safe — if name is null, name.length() is never called
    System.out.println("Name: " + name);
}

// || short-circuits on first true:
if (cache.contains(key) || loadFromDatabase(key)) {
    // if cache hit, database is never queried
}

// Non-short-circuit versions — & and | evaluate BOTH sides always:
boolean a = false;
boolean b = someExpensiveMethod();  // called even though a is false
boolean result = a & b;             // both evaluated regardless

// When to use & and | (non-short-circuit):
// — when both sides must execute (side effects)
// — in bitwise operations on integers (not booleans)

// Common pattern — null-safe method chaining:
if (user != null
        && user.getAddress() != null
        && user.getAddress().getCity() != null) {
    System.out.println(user.getAddress().getCity());
}

// Integer arithmetic — result is int minimum:
byte b = 10;
byte b2 = 20;
// byte sum = b + b2;   // COMPILE ERROR — result is int
int sum = b + b2;       // correct

// Mixed integer types — result is the larger type:
int i = 100;
long l = 200L;
long mixed = i + l;     // int promoted to long — result is long

// Mixed with floating point — result is the floating-point type:
int x = 5;
double d = 2.5;
double result = x + d;  // int promoted to double — result is double

// Integer division vs floating-point division:
int a = 7, b3 = 2;
int intDiv = a / b3;          // 3 — integer division
double fpDiv = a / b3;        // 3.0 — still integer division! widened after
double fpDiv2 = (double) a / b3;  // 3.5 — correct: cast before dividing

// String + anything = String:
String s = "Value: " + 42;       // "Value: 42"
String s2 = "Sum: " + (1 + 2);   // "Sum: 3" — parens force int addition first
String s3 = "Sum: " + 1 + 2;     // "Sum: 12" — left-to-right, both concat