Java Language Specification — Math Operations¶

int max = Integer.MAX_VALUE;
System.out.println(max + 1);          // -2147483648 (no exception)
System.out.println(max * 2);          // -2 (wrap)

// Safe: Math.addExact throws ArithmeticException on overflow
int safe = Math.addExact(max, 1);     // throws ArithmeticException

int x = 1;
System.out.println(x << 32);   // 1 (not 0! — 32 mod 32 == 0)
System.out.println(x << 33);   // 2 (33 mod 32 == 1)
long y = 1L;
System.out.println(y << 64);   // 1L (64 mod 64 == 0)

byte b = 100;
b += 50;  // legal: equivalent to b = (byte)(b + 50) = (byte)150 = -106
System.out.println(b);   // -106 (not a compile error!)

System.out.println(1 + 2 + " apples");    // "3 apples" (1+2=3, then concat)
System.out.println("apples: " + 1 + 2);   // "apples: 12" (concat left to right)
System.out.println("apples: " + (1 + 2)); // "apples: 3"

int count = 0;
boolean result = true || (++count > 0);  // right side NOT evaluated
System.out.println(count);  // 0 (not 1)

boolean result2 = false && (++count > 0); // right side NOT evaluated
System.out.println(count);  // still 0

System.out.println(Math.abs(Integer.MIN_VALUE));  // -2147483648 (overflow!)
System.out.println(Math.abs(Long.MIN_VALUE));      // -9223372036854775808 (overflow!)
// Use Math.absExact() (Java 15+) for overflow detection:
Math.absExact(Integer.MIN_VALUE);  // throws ArithmeticException

// Example 1: Arithmetic Operators
// File: ArithmeticOps.java
public class ArithmeticOps {
    public static void main(String[] args) {
        int a = 17, b = 5;

        System.out.println("a + b = " + (a + b));    // 22
        System.out.println("a - b = " + (a - b));    // 12
        System.out.println("a * b = " + (a * b));    // 85
        System.out.println("a / b = " + (a / b));    // 3 (integer division)
        System.out.println("a % b = " + (a % b));    // 2

        // Negative modulo
        System.out.println("-17 % 5 = " + (-17 % 5));  // -2 (sign of dividend)
        System.out.println("17 % -5 = " + (17 % -5));  // 2

        // Pre/post increment
        int x = 10;
        System.out.println(x++);   // 10 (old value)
        System.out.println(x);     // 11
        System.out.println(++x);   // 12 (new value)
        System.out.println(x);     // 12

        // Overflow
        int max = Integer.MAX_VALUE;
        System.out.println("MAX + 1 = " + (max + 1));  // -2147483648 (wrap)

        // Checked arithmetic (Java 8+)
        try {
            Math.addExact(Integer.MAX_VALUE, 1);
        } catch (ArithmeticException e) {
            System.out.println("Overflow: " + e.getMessage());
        }

        // clamp (Java 21+)
        int value = 150;
        int clamped = Math.clamp(value, 0, 100);
        System.out.println("clamp(150, 0, 100) = " + clamped);  // 100
    }
}

// Example 2: Bitwise and Shift Operators
// File: BitwiseOps.java
public class BitwiseOps {
    public static void main(String[] args) {
        int a = 0b1100;  // 12
        int b = 0b1010;  // 10

        System.out.printf("a & b  = %4d  (%s)%n", a & b,  Integer.toBinaryString(a & b));  // 8  1000
        System.out.printf("a | b  = %4d  (%s)%n", a | b,  Integer.toBinaryString(a | b));  // 14 1110
        System.out.printf("a ^ b  = %4d  (%s)%n", a ^ b,  Integer.toBinaryString(a ^ b));  // 6  0110
        System.out.printf("~a     = %4d%n", ~a);     // -13

        // Shifts
        int n = 1;
        System.out.println("1 << 3 = " + (n << 3));    // 8
        System.out.println("8 >> 1 = " + (8 >> 1));    // 4
        System.out.println("-8 >> 1 = " + (-8 >> 1));  // -4 (arithmetic: fill with 1)
        System.out.println("-8 >>> 1 = " + (-8 >>> 1)); // large positive (logical: fill with 0)

        // Useful bit tricks
        int flags = 0;
        int FLAG_A = 1 << 0;  // bit 0
        int FLAG_B = 1 << 1;  // bit 1
        int FLAG_C = 1 << 2;  // bit 2

        flags |= FLAG_A;                              // set FLAG_A
        flags |= FLAG_C;                              // set FLAG_C
        System.out.println("FLAG_A set: " + ((flags & FLAG_A) != 0));  // true
        System.out.println("FLAG_B set: " + ((flags & FLAG_B) != 0));  // false
        flags ^= FLAG_A;                              // toggle FLAG_A
        System.out.println("FLAG_A after toggle: " + ((flags & FLAG_A) != 0));  // false
    }
}

// Example 3: Math Class Usage
// File: MathDemo.java
public class MathDemo {
    public static void main(String[] args) {
        // Basic Math
        System.out.println(Math.abs(-42));            // 42
        System.out.println(Math.abs(Integer.MIN_VALUE)); // -2147483648 (edge case!)
        System.out.println(Math.max(10, 20));          // 20
        System.out.println(Math.min(10, 20));          // 10

        // Powers and roots
        System.out.println(Math.pow(2, 10));           // 1024.0
        System.out.println(Math.sqrt(144));            // 12.0
        System.out.println(Math.cbrt(27));             // 3.0
        System.out.println(Math.sqrt(-1));             // NaN

        // Rounding
        System.out.println(Math.floor(3.7));           // 3.0
        System.out.println(Math.ceil(3.2));            // 4.0
        System.out.println(Math.round(3.5));           // 4
        System.out.println(Math.round(3.4));           // 3
        System.out.println(Math.round(-3.5));          // -3 (rounds toward +infinity)

        // Logarithms and trig
        System.out.println(Math.log(Math.E));          // 1.0
        System.out.println(Math.log10(1000));          // 3.0
        System.out.printf("sin(90°) = %.2f%n", Math.sin(Math.PI / 2));  // 1.00
        System.out.printf("cos(0°)  = %.2f%n", Math.cos(0));            // 1.00

        // Constants
        System.out.println("PI = " + Math.PI);
        System.out.println("E  = " + Math.E);

        // FMA (Java 9+) — fused multiply-add, single rounding
        double fma = Math.fma(2.0, 3.0, 4.0);  // 2.0*3.0 + 4.0 = 10.0
        System.out.println("fma(2, 3, 4) = " + fma);

        // clamp (Java 21)
        System.out.println(Math.clamp(5.5, 0.0, 10.0));   // 5.5
        System.out.println(Math.clamp(-3.0, 0.0, 10.0));  // 0.0
        System.out.println(Math.clamp(15.0, 0.0, 10.0));  // 10.0
    }
}

// Example 4: Operator Precedence and Short-Circuit
// File: OperatorPrecedence.java
public class OperatorPrecedence {

    static int sideEffect(String label, int value) {
        System.out.println("Evaluating: " + label);
        return value;
    }

    public static void main(String[] args) {
        // Precedence: * before +
        int result = 2 + 3 * 4;
        System.out.println(result);            // 14 (not 20)

        // Left-to-right evaluation for + with strings
        System.out.println(1 + 2 + "3");      // "33" (1+2=3, then "3"+"3"="33")
        System.out.println("1" + 2 + 3);      // "123" (string concat left-to-right)
        System.out.println("1" + (2 + 3));    // "15" (parentheses override)

        // Short-circuit: second operand not evaluated
        System.out.println("--- Short-circuit AND ---");
        boolean r1 = false && (sideEffect("right-AND", 1) > 0);  // right NOT evaluated
        System.out.println("result: " + r1);

        System.out.println("--- Short-circuit OR ---");
        boolean r2 = true || (sideEffect("right-OR", 1) > 0);   // right NOT evaluated
        System.out.println("result: " + r2);

        System.out.println("--- Non-short-circuit ---");
        boolean r3 = false & (sideEffect("right-&", 1) > 0);   // right IS evaluated
        System.out.println("result: " + r3);

        // Ternary operator
        int x = 7;
        String category = x > 5 ? "big" : x > 2 ? "medium" : "small";  // right-assoc
        System.out.println(category);  // "big"

        // Assignment operators
        int n = 10;
        n += 5;   System.out.println(n);   // 15
        n -= 3;   System.out.println(n);   // 12
        n *= 2;   System.out.println(n);   // 24
        n /= 4;   System.out.println(n);   // 6
        n %= 4;   System.out.println(n);   // 2
        n <<= 3;  System.out.println(n);   // 16
        n >>= 1;  System.out.println(n);   // 8
    }
}

// Example 5: Floating-Point Arithmetic
// File: FloatArithmetic.java
public class FloatArithmetic {
    public static void main(String[] args) {
        // Precision issues
        System.out.println(0.1 + 0.2);             // 0.30000000000000004
        System.out.println(0.1 + 0.2 == 0.3);      // false!

        // Use epsilon comparison
        double a = 0.1 + 0.2;
        double b = 0.3;
        double eps = 1e-9;
        System.out.println(Math.abs(a - b) < eps);  // true

        // Use BigDecimal for exact decimal arithmetic
        java.math.BigDecimal bd1 = new java.math.BigDecimal("0.1");
        java.math.BigDecimal bd2 = new java.math.BigDecimal("0.2");
        System.out.println(bd1.add(bd2));           // 0.3 (exact)

        // Rounding modes
        double val = 2.5;
        System.out.println(Math.round(val));        // 3 (rounds to nearest, ties up)
        System.out.println(Math.rint(val));         // 2.0 (rounds to nearest, ties to even)
        System.out.println(Math.round(3.5));        // 4
        System.out.println(Math.rint(3.5));         // 4.0 (even)
        System.out.println(Math.rint(4.5));         // 4.0 (even, not 5!)

        // Special values
        double posInf = 1.0 / 0.0;
        double negInf = -1.0 / 0.0;
        double nan = 0.0 / 0.0;

        System.out.println(posInf > Double.MAX_VALUE);  // true
        System.out.println(negInf < -Double.MAX_VALUE); // true
        System.out.println(nan == nan);                  // false
        System.out.println(Double.isNaN(nan));           // true
        System.out.println(posInf + 1);                  // Infinity
        System.out.println(posInf - posInf);             // NaN
    }
}