Java Operators — Types, Syntax, Examples & Best Practices

public class ArithmeticOperators {
    public static void main(String[] args) {

        int a = 15, b = 4;

        // Basic arithmetic
        System.out.println(a + b);   // 19 — addition
        System.out.println(a - b);   // 11 — subtraction
        System.out.println(a * b);   // 60 — multiplication
        System.out.println(a / b);   // 3  — integer division (NOT 3.75!)
        System.out.println(a % b);   // 3  — remainder (15 = 4*3 + 3)

        // ✅ Correct: float division
        System.out.println((double) a / b);  // 3.75
        System.out.println(a / 4.0);         // 3.75

        // ✅ String concatenation vs addition
        System.out.println("Sum: " + a + b);    // 'Sum: 154' — concatenation!
        System.out.println("Sum: " + (a + b));  // 'Sum: 19'  — add first
        System.out.println(a + b + " is sum");  // '19 is sum' — adds first (no String left)

        // ✅ Modulus use cases
        System.out.println(10 % 2 == 0 ? "Even" : "Odd"); // Even
        System.out.println(7 % 2 == 0 ? "Even" : "Odd");  // Odd

        // ✅ ArithmeticException: division by zero (integer only)
        // int x = 5 / 0;     // ❌ Throws ArithmeticException: / by zero
        double y = 5.0 / 0;   // ✅ Returns Infinity (no exception for double)
        double z = 0.0 / 0;   // ✅ Returns NaN (Not a Number)
        System.out.println(y); // Infinity
        System.out.println(z); // NaN
    }
}

public class RelationalOperators {
    public static void main(String[] args) {

        int x = 10, y = 20;

        System.out.println(x == y);  // false — equal to
        System.out.println(x != y);  // true  — not equal to
        System.out.println(x > y);   // false — greater than
        System.out.println(x < y);   // true  — less than
        System.out.println(x >= 10); // true  — greater than or equal
        System.out.println(x <= 10); // true  — less than or equal

        // ⚠️ CRITICAL: == on objects compares REFERENCES, not content
        String s1 = new String("Java");
        String s2 = new String("Java");
        System.out.println(s1 == s2);       // false — different objects!
        System.out.println(s1.equals(s2));  // true  — same content ✅

        // ⚠️ String pool: literals may share reference — don't rely on this
        String s3 = "Java";
        String s4 = "Java";
        System.out.println(s3 == s4);  // true (pool) — but NEVER use == for Strings

        // ✅ For primitives, == compares values
        int a = 100, b = 100;
        System.out.println(a == b);  // true — primitives: value comparison

        // ✅ Wrapper Integer: == only reliable for -128 to 127 (cache range)
        Integer i1 = 100, i2 = 100;
        System.out.println(i1 == i2);      // true  (cached)
        Integer i3 = 200, i4 = 200;
        System.out.println(i3 == i4);      // false (outside cache — new objects!)
        System.out.println(i3.equals(i4)); // true  ✅ always use .equals() for wrappers
    }
}

public class LogicalOperators {
    public static void main(String[] args) {

        boolean a = true, b = false;

        // Basic logical operations
        System.out.println(a && b);  // false — AND: both must be true
        System.out.println(a || b);  // true  — OR: at least one true
        System.out.println(!a);       // false — NOT: inverts
        System.out.println(!b);       // true

        // ✅ Short-circuit AND — prevents NullPointerException
        String str = null;
        if (str != null && str.length() > 0) {  // str.length() never called if str == null
            System.out.println("Non-empty string");
        } else {
            System.out.println("String is null or empty"); // Safe!
        }

        // ✅ Short-circuit OR — right side only runs if left is false
        int count = 0;
        boolean result = (count > 0) || (++count > 0);
        System.out.println(count);  // 1 — right side WAS evaluated (left was false)

        int count2 = 1;
        boolean result2 = (count2 > 0) || (++count2 > 0);
        System.out.println(count2); // 1 — right side NOT evaluated (left was true, short-circuit!)

        // ✅ Combining logical operators
        int age = 25;
        boolean hasId = true;
        boolean isMinor = age < 18;

        if (!isMinor && hasId) {
            System.out.println("Access granted");
        }

        // ✅ De Morgan's Laws — useful for simplifying conditions
        // !(a && b) == (!a || !b)
        // !(a || b) == (!a && !b)
        boolean x = true, y = false;
        System.out.println(!(x && y));      // true
        System.out.println(!x || !y);       // true — equivalent!
    }
}

public class AssignmentOperators {
    public static void main(String[] args) {

        int x = 10;  // Basic assignment

        // ✅ Compound assignment operators
        x += 5;   System.out.println(x);  // 15 — x = x + 5
        x -= 3;   System.out.println(x);  // 12 — x = x - 3
        x *= 2;   System.out.println(x);  // 24 — x = x * 2
        x /= 4;   System.out.println(x);  // 6  — x = x / 4
        x %= 4;   System.out.println(x);  // 2  — x = x % 4

        // ✅ Bitwise compound assignment
        x &= 3;   System.out.println(x);  // 2  — x = x & 3
        x |= 5;   System.out.println(x);  // 7  — x = x | 5
        x ^= 2;   System.out.println(x);  // 5  — x = x ^ 2
        x <<= 1;  System.out.println(x);  // 10 — x = x << 1
        x >>= 1;  System.out.println(x);  // 5  — x = x >> 1

        // ✅ Implicit narrowing cast with compound assignment
        byte b = 10;
        // b = b + 5;    // ❌ Compile error: int cannot be converted to byte
        b += 5;          // ✅ Works! Compound += includes implicit (byte) cast
        System.out.println(b); // 15

        // ✅ Chained assignment
        int a, c, d;
        a = c = d = 100;  // All assigned 100 — right to left
        System.out.println(a + " " + c + " " + d); // 100 100 100

        // ✅ Assignment is itself an expression (returns assigned value)
        int val;
        if ((val = getValue()) > 0) {  // Assigns AND checks in one step
            System.out.println("Positive: " + val);
        }
    }

    static int getValue() { return 42; }
}

public class UnaryOperators {
    public static void main(String[] args) {

        int a = 5;

        // Unary plus and minus
        System.out.println(+a);   // 5  — unary plus (no change for positive)
        System.out.println(-a);   // -5 — negation

        // ✅ Logical NOT
        boolean flag = true;
        System.out.println(!flag);   // false
        System.out.println(!!flag);  // true  — double negation

        // ✅ Prefix vs Postfix — the key difference
        int x = 10;
        System.out.println(x++);  // 10 — returns CURRENT value, THEN increments
        System.out.println(x);    // 11 — x has been incremented

        int y = 10;
        System.out.println(++y);  // 11 — increments FIRST, then returns NEW value
        System.out.println(y);    // 11

        // ✅ Postfix in a loop (most common use)
        for (int i = 0; i < 3; i++) {  // i++ is fine here as standalone
            System.out.print(i + " ");  // 0 1 2
        }
        System.out.println();

        // ⚠️ Tricky: prefix in assignment
        int n = 5;
        int result = ++n * 2;  // n becomes 6 first, then 6 * 2 = 12
        System.out.println(result); // 12
        System.out.println(n);      // 6

        // ⚠️ Even trickier — avoid this in real code
        int m = 5;
        int tricky = m++ + ++m;  // m++ returns 5 (m→6), ++m returns 7 (m→7): 5+7=12
        System.out.println(tricky); // 12 — but this style is unreadable, avoid it!
    }
}

public class BitwiseOperators {

    // ✅ Real-world: permission flags using bitwise operators
    static final int READ    = 0b001;  // 1
    static final int WRITE   = 0b010;  // 2
    static final int EXECUTE = 0b100;  // 4

    public static void main(String[] args) {

        int a = 12; // Binary: 1100
        int b = 10; // Binary: 1010

        System.out.println(a & b);  // 8  — 1100 & 1010 = 1000
        System.out.println(a | b);  // 14 — 1100 | 1010 = 1110
        System.out.println(a ^ b);  // 6  — 1100 ^ 1010 = 0110
        System.out.println(~a);     // -13 — inverts all bits of 12

        // ✅ Permission system using bitwise OR to grant, AND to check
        int userPermissions = READ | WRITE;  // 001 | 010 = 011 (3)

        boolean canRead    = (userPermissions & READ)    != 0;  // true
        boolean canWrite   = (userPermissions & WRITE)   != 0;  // true
        boolean canExecute = (userPermissions & EXECUTE) != 0;  // false

        System.out.println("Read: " + canRead);      // true
        System.out.println("Write: " + canWrite);    // true
        System.out.println("Execute: " + canExecute); // false

        // ✅ Grant execute permission
        userPermissions |= EXECUTE;
        System.out.println("Execute after grant: " + ((userPermissions & EXECUTE) != 0)); // true

        // ✅ Revoke write permission
        userPermissions &= ~WRITE;
        System.out.println("Write after revoke: " + ((userPermissions & WRITE) != 0));  // false

        // ✅ Toggle read permission with XOR
        userPermissions ^= READ;
        System.out.println("Read after toggle: " + ((userPermissions & READ) != 0)); // false (was true)

        // ✅ Fast even/odd check with bitwise AND
        for (int i = 0; i <= 5; i++) {
            System.out.println(i + " is " + ((i & 1) == 0 ? "even" : "odd"));
        }
    }
}

public class ShiftOperators {
    public static void main(String[] args) {

        int n = 8; // Binary: 00001000

        // ✅ Left shift — multiply by power of 2
        System.out.println(n << 1);  // 16  — 8 * 2^1
        System.out.println(n << 2);  // 32  — 8 * 2^2
        System.out.println(n << 3);  // 64  — 8 * 2^3

        // ✅ Signed right shift — divide by power of 2
        System.out.println(64 >> 1); // 32  — 64 / 2^1
        System.out.println(64 >> 2); // 16  — 64 / 2^2
        System.out.println(64 >> 3); // 8   — 64 / 2^3

        // ✅ Signed right shift preserves sign
        System.out.println(-64 >> 2); // -16 — sign preserved

        // ✅ Unsigned right shift — sign bit filled with 0
        System.out.println(-1 >>> 1);  // 2147483647 (Integer.MAX_VALUE) — sign gone
        System.out.println(-64 >>> 2); // large positive number

        // ✅ Real-world: fast power of 2 check using bit manipulation
        int num = 64;
        boolean isPowerOfTwo = (num > 0) && (num & (num - 1)) == 0;
        System.out.println(num + " is power of 2: " + isPowerOfTwo); // true

        // ✅ HashMap-style hash spreading (from Java source)
        int hash = 12345678;
        int spread = hash ^ (hash >>> 16);  // XOR with upper 16 bits
        System.out.println("Spread hash: " + spread);

        // ✅ Extract RGB color components from packed int
        int color = 0xFF5733AA; // packed ARGB
        int alpha = (color >> 24) & 0xFF;
        int red   = (color >> 16) & 0xFF;
        int green = (color >> 8)  & 0xFF;
        int blue  =  color        & 0xFF;
        System.out.printf("A=%d R=%d G=%d B=%d%n", alpha, red, green, blue);
    }
}

public class TernaryOperator {
    public static void main(String[] args) {

        int a = 15, b = 20;

        // ✅ Basic ternary — compact if-else
        int max = (a > b) ? a : b;
        System.out.println("Max: " + max); // 20

        int min = (a < b) ? a : b;
        System.out.println("Min: " + min); // 15

        // ✅ Ternary in string concatenation
        int score = 75;
        System.out.println("Result: " + (score >= 60 ? "Pass" : "Fail")); // Pass

        // ✅ Ternary as method argument
        printStatus(score >= 60 ? "Pass" : "Fail");

        // ✅ Null check pattern
        String name = null;
        String displayName = (name != null) ? name : "Guest";
        System.out.println(displayName); // Guest

        // ✅ Chained ternary (use sparingly — readability drops fast)
        int marks = 85;
        String grade = (marks >= 90) ? "A" :
                       (marks >= 80) ? "B" :
                       (marks >= 70) ? "C" :
                       (marks >= 60) ? "D" : "F";
        System.out.println("Grade: " + grade); // B

        // ⚠️ Bad practice: ternary with side effects — avoid
        int count = 0;
        // int x = (count++ > 0) ? count++ : count--;  // Confusing — use if-else instead
    }

    static void printStatus(String status) {
        System.out.println("Status: " + status);
    }
}

class Animal { }
class Dog extends Animal {
    public void fetch() { System.out.println("Fetching!"); }
}
class Cat extends Animal {
    public void purr() { System.out.println("Purring!"); }
}

public class InstanceofOperator {
    public static void main(String[] args) {

        Animal a1 = new Dog();
        Animal a2 = new Cat();
        Animal a3 = null;

        // ✅ Basic instanceof check
        System.out.println(a1 instanceof Animal); // true  — Dog IS-A Animal
        System.out.println(a1 instanceof Dog);    // true  — actual type is Dog
        System.out.println(a1 instanceof Cat);    // false — Dog is NOT a Cat
        System.out.println(a3 instanceof Animal); // false — null is never instanceof anything

        // ✅ Traditional usage — check then cast
        if (a1 instanceof Dog) {
            Dog d = (Dog) a1;   // Safe cast after instanceof check
            d.fetch();
        }

        // ✅ Java 16+ Pattern Matching — check AND cast in one step
        if (a1 instanceof Dog dog) {   // 'dog' is automatically cast and in scope
            dog.fetch();               // No explicit (Dog) cast needed!
        }

        if (a2 instanceof Cat cat) {
            cat.purr();
        }

        // ✅ Pattern matching in a loop (polymorphic processing)
        Animal[] animals = { new Dog(), new Cat(), new Dog() };
        for (Animal animal : animals) {
            if (animal instanceof Dog d) {
                d.fetch();
            } else if (animal instanceof Cat c) {
                c.purr();
            }
        }

        // ✅ instanceof with interfaces
        java.util.List<String> list = new java.util.ArrayList<>();
        System.out.println(list instanceof java.util.List);       // true
        System.out.println(list instanceof java.util.Collection); // true
        System.out.println(list instanceof java.util.Iterable);   // true
    }
}

public class OperatorPrecedence {
    public static void main(String[] args) {

        // * has higher precedence than +
        int a = 2 + 3 * 4;           // 2 + 12 = 14 (NOT 20)
        System.out.println(a);        // 14

        // Parentheses override precedence
        int b = (2 + 3) * 4;          // 5 * 4 = 20
        System.out.println(b);        // 20

        // Relational before equality
        boolean c = 5 > 3 == true;    // (5 > 3) == true → true == true → true
        System.out.println(c);        // true

        // && has higher precedence than ||
        boolean d = true || false && false;  // true || (false && false) → true || false → true
        System.out.println(d); // true

        boolean e = (true || false) && false; // true && false → false
        System.out.println(e); // false

        // Assignment is right-to-left
        int x, y, z;
        x = y = z = 5;  // z=5 first, then y=5, then x=5
        System.out.println(x + " " + y + " " + z); // 5 5 5

        // Tricky: + and string concatenation
        System.out.println(1 + 2 + "3");   // '33' — left to right: 1+2=3, then 3+"3"
        System.out.println("1" + 2 + 3);   // '123' — left to right: "1"+2="12", then "12"+3
        System.out.println("1" + (2 + 3)); // '15' — parentheses: 2+3=5, then "1"+5
    }
}

// ❌ MISTAKE 1: Integer division when float result expected
int total = 7, count = 2;
double avg = total / count;  // 3.0 — NOT 3.5!
// ✅ Fix:
double avgFixed = (double) total / count;  // 3.5

// ❌ MISTAKE 2: Using == for String comparison
String s1 = new String("hello");
String s2 = new String("hello");
if (s1 == s2) { ... }         // Always false for new String()
// ✅ Fix:
if (s1.equals(s2)) { ... }    // Correct: compare content

// ❌ MISTAKE 3: Confusing = (assignment) with == (comparison)
int x = 5;
// if (x = 10) { ... }    // Compile error in Java (unlike C) — but still easy to misread
if (x == 10) { ... }      // Correct comparison

// ❌ MISTAKE 4: Not accounting for operator precedence
boolean result = 2 + 3 > 4 && 5 < 10 || 1 == 1;
// Actual: ((2+3) > 4) && (5 < 10) || (1 == 1) → true && true || true → true
// ✅ Fix: use parentheses for clarity
boolean resultClear = ((2 + 3) > 4) && (5 < 10) || (1 == 1);

// ❌ MISTAKE 5: Modulus with negative numbers
System.out.println(-7 % 3);   // -1 (NOT 2) — sign follows dividend in Java
// ✅ Fix for always-positive remainder:
System.out.println(Math.floorMod(-7, 3)); // 2 — always positive

// ❌ MISTAKE 6: Overflow in integer arithmetic (silent bug)
int maxVal = Integer.MAX_VALUE;
System.out.println(maxVal + 1);  // -2147483648 — integer overflow, no exception!
// ✅ Fix: use long or check before operation
long safeResult = (long) maxVal + 1;  // 2147483648 — correct

// ❌ MISTAKE 7: Division by zero for integers (throws exception)
// int bad = 10 / 0;   // ArithmeticException: / by zero
// ✅ Always check divisor before dividing
int divisor = 0;
if (divisor != 0) { int safe = 10 / divisor; }

package com.techsustainify.order.service;

import java.util.Objects;

public class OrderService {

    private static final int MAX_QUANTITY   = 100;
    private static final double TAX_RATE    = 0.18;
    private static final double DISCOUNT_THRESHOLD = 1000.0;

    // ✅ Relational + logical operators in validation
    public boolean isValidOrder(String productId, int quantity, double unitPrice) {
        return productId != null          // null check
            && !productId.isBlank()       // logical AND — short-circuit
            && quantity > 0               // relational
            && quantity <= MAX_QUANTITY   // relational
            && unitPrice > 0.0;           // relational
    }

    // ✅ Arithmetic + ternary operators in pricing calculation
    public double calculateTotal(int quantity, double unitPrice, String couponCode) {
        double subtotal = quantity * unitPrice;  // arithmetic

        // ✅ Ternary for inline conditional discount
        double discount = (subtotal > DISCOUNT_THRESHOLD) ? subtotal * 0.10 : 0.0;

        // ✅ Ternary for coupon code bonus
        double couponDiscount = (couponCode != null && couponCode.equals("SAVE20"))
                                ? subtotal * 0.20 : 0.0;

        double discountedAmount = subtotal - discount - couponDiscount;
        double tax              = discountedAmount * TAX_RATE;  // arithmetic
        return discountedAmount + tax;
    }

    // ✅ Bitwise operators for order status flags
    private static final int STATUS_PLACED    = 0b00001;  // 1
    private static final int STATUS_PAID      = 0b00010;  // 2
    private static final int STATUS_SHIPPED   = 0b00100;  // 4
    private static final int STATUS_DELIVERED = 0b01000;  // 8
    private static final int STATUS_CANCELLED = 0b10000;  // 16

    public int processOrder(int currentStatus) {
        // Set PAID flag using bitwise OR
        currentStatus |= STATUS_PAID;
        // Set SHIPPED flag
        currentStatus |= STATUS_SHIPPED;
        return currentStatus;
    }

    public boolean isDelivered(int status) {
        return (status & STATUS_DELIVERED) != 0;  // bitwise AND to check flag
    }

    // ✅ instanceof + pattern matching for polymorphic handling
    public double applyPaymentFee(Object payment) {
        if (payment instanceof CreditCardPayment cc) {
            return cc.getAmount() * 0.02;  // 2% fee
        } else if (payment instanceof UpiPayment upi) {
            return 0.0;   // No fee for UPI
        } else if (payment instanceof NetBankingPayment nb) {
            return nb.getAmount() >= 10000 ? 0.0 : 15.0;  // ternary
        }
        throw new IllegalArgumentException("Unknown payment type");
    }

    // ✅ Shift operators for fast power-of-2 page size calculation
    public int getPageSizeBytes(int pageSizeKB) {
        return pageSizeKB << 10;  // * 1024 — same as pageSizeKB * 2^10
    }
}

package com.techsustainify.util;

import java.util.Objects;

public class ValidationUtils {

    // ✅ Short-circuit AND for null-safe chained calls
    public static boolean isNonEmptyString(String s) {
        return s != null && !s.isEmpty() && !s.isBlank();
        // If s is null, the right sides are never evaluated — no NPE
    }

    // ✅ Objects.equals for null-safe object comparison (avoids manual null check)
    public static boolean safeEquals(Object a, Object b) {
        return Objects.equals(a, b);  // Handles null gracefully — no NPE
    }

    // ✅ Math.floorMod for always-positive modulus (unlike %)
    public static int circularIndex(int index, int size) {
        return Math.floorMod(index, size);  // Works correctly for negative index
    }

    // ✅ Math.addExact for overflow-safe addition
    public static long safeAdd(int a, int b) {
        try {
            return Math.addExact(a, b);
        } catch (ArithmeticException e) {
            throw new IllegalStateException("Integer overflow in addition", e);
        }
    }

    // ✅ Ternary for null-safe default values
    public static String defaultIfNull(String value, String defaultValue) {
        return value != null ? value : defaultValue;
        // Or simply: Objects.requireNonNullElse(value, defaultValue)
    }

    // ✅ Compound assignment in streaming aggregation
    public static double sumDiscounted(java.util.List<Double> prices, double discountPct) {
        double total = 0.0;
        for (double price : prices) {
            total += price * (1.0 - discountPct / 100.0);  // compound += each item
        }
        return total;
    }
}