{"title":"Operators","description":"","content":"Operators are the small symbols that do the actual work in a Java expression. They add prices, compare quantities, combine boolean conditions, and decide which branch of a decision wins. This lesson walks through every operator family Java offers, along with common gotchas.\n\n---\n\n# Arithmetic Operators\n\nThe five arithmetic operators (`+`, `-`, `*`, `/`, `%`) work on numeric primitives like `int`, `long`, `double`, and `float`. They behave the way ordinary math does, with two important wrinkles.\n\n\n| Operator | Name | Example | Result |\n| -------- | ----------- | -------- | ------ |\n| `+` | Addition | `5 + 3` | `8` |\n| `-` | Subtraction | `5 - 3` | `2` |\n| `*` | Multiply | `5 * 3` | `15` |\n| `/` | Division | `7 / 2` | `3` |\n| `%` | Modulo | `7 % 3` | `1` |\n\n\nA typical e-commerce calculation:\n\n\n```java\npublic class CartTotal {\n public static void main(String[] args) {\n double unitPrice = 19.99;\n int quantity = 3;\n double subtotal = unitPrice * quantity;\n double tax = subtotal * 0.08;\n double total = subtotal + tax;\n System.out.println(\"Subtotal: $\" + subtotal);\n System.out.println(\"Tax: $\" + tax);\n System.out.println(\"Total: $\" + total);\n }\n}\n```\n\n\n### Integer Division\n\nWhen both operands are integers, `/` performs integer division and throws away the remainder. The result is not rounded, it's truncated toward zero. `7 / 2` is `3`, not `3.5`, and not `4`.\n\n\n```java\npublic class IntegerDivision {\n public static void main(String[] args) {\n int totalItems = 7;\n int boxes = 2;\n int itemsPerBox = totalItems / boxes;\n System.out.println(\"Items per box: \" + itemsPerBox);\n }\n}\n```\n\n\nThis matters most when you actually want a decimal answer. Splitting a $25 bill across 4 people:\n\n\n```java\npublic class SplitBill {\n public static void main(String[] args) {\n int total = 25;\n int people = 4;\n int wrong = total / people;\n double right = (double) total / people;\n System.out.println(\"Wrong: \" + wrong);\n System.out.println(\"Right: \" + right);\n }\n}\n```\n\n\nThe fix is to make at least one operand a floating-point number. Either cast one side with `(double)`, write the literal as `25.0`, or store the value in a `double` from the start.\n\n### Modulo with Negatives\n\nThe `%` operator returns the remainder after division. For positive numbers it's the expected value, but the sign rule with negatives is worth noting: in Java, the sign of the result follows the **dividend** (the left operand), not the divisor.\n\n\n| Expression | Result |\n| ---------- | ------ |\n| `7 % 3` | `1` |\n| `-7 % 3` | `-1` |\n| `7 % -3` | `1` |\n| `-7 % -3` | `-1` |\n\n\n\n```java\npublic class ModuloSigns {\n public static void main(String[] args) {\n System.out.println(7 % 3);\n System.out.println(-7 % 3);\n System.out.println(7 % -3);\n System.out.println(-7 % -3);\n }\n}\n```\n\n\n`%` is common in \"every Nth\" logic: free shipping every 5th order, alternating colors in a list, checking if a number is even with `n % 2 == 0`.\n\n### String Concatenation with `+`\n\nThe `+` operator is special. If either operand is a `String`, `+` becomes string concatenation instead of arithmetic. Java converts the other side to a string and glues them together.\n\n\n```java\npublic class CartLabel {\n public static void main(String[] args) {\n String customerName = \"Alex\";\n int itemCount = 3;\n String label = customerName + \"'s cart has \" + itemCount + \" items\";\n System.out.println(label);\n }\n}\n```\n\n\nThis is convenient, but it can produce surprises when arithmetic and concatenation mix. Evaluation is left to right, so the position of the first `String` matters:\n\n\n```java\npublic class ConcatTrap {\n public static void main(String[] args) {\n System.out.println(\"Total: \" + 2 + 3);\n System.out.println(\"Total: \" + (2 + 3));\n System.out.println(2 + 3 + \" items\");\n }\n}\n```\n\n\nThe first line concatenates `\"Total: \"` with `2` to get `\"Total: 2\"`, then concatenates `3` to get `\"Total: 23\"`. Parentheses force the addition to happen first. In the third line, both operands are `int` at the start, so addition runs before the string ever shows up.\n\nConcatenating strings in a loop with `+` allocates a new `String` on every iteration, because `String` is immutable. For long lists or large strings, use `StringBuilder` instead.\n\n---\n\n# Unary Operators\n\nUnary operators take a single operand. The two that matter most are `++` (increment) and `--` (decrement), each with a pre- and post-form.\n\n\n| Operator | Name | Example | Effect |\n| -------- | -------------- | -------- | --------------------------------------- |\n| `+x` | Unary plus | `+price` | Returns `price` unchanged |\n| `-x` | Unary minus | `-price` | Returns the negation |\n| `++x` | Pre-increment | `++x` | Adds 1, then returns the new value |\n| `x++` | Post-increment | `x++` | Returns the current value, then adds 1 |\n| `--x` | Pre-decrement | `--x` | Subtracts 1, then returns the new value |\n| `x--` | Post-decrement | `x--` | Returns the current value, then subtracts 1 |\n\n\nThe key difference between pre and post is **when** the change is visible to the surrounding expression. The variable always ends up changed; the only question is whether the expression sees the old value or the new one.\n\n\n```java\npublic class IncrementWalkthrough {\n public static void main(String[] args) {\n int x = 5;\n System.out.println(x++ + \" \" + ++x);\n }\n}\n```\n\n\nWalking through this step by step:\n\n1. `x` starts at `5`.\n2. `x++` evaluates to `5` (the current value), then `x` becomes `6`.\n3. `++x` first increments `x` to `7`, then evaluates to `7`.\n4. The final printed line is `5 7`. After the statement, `x` is `7`.\n\nPre vs post matters only when the increment is part of a bigger expression. As a standalone statement, `x++;` and `++x;` do the same thing.\n\n---\n\n# Relational Operators\n\nRelational operators compare two values and produce a `boolean` (`true` or `false`).\n\n\n| Operator | Meaning | Example | Result |\n| -------- | ---------------------- | ------------- | ------- |\n| `==` | Equal to | `5 == 5` | `true` |\n| `!=` | Not equal to | `5 != 3` | `true` |\n| `<` | Less than | `5 < 10` | `true` |\n| `>` | Greater than | `5 > 10` | `false` |\n| `<=` | Less than or equal | `5 <= 5` | `true` |\n| `>=` | Greater than or equal | `5 >= 6` | `false` |\n\n\nFor primitives, all six operators compare values. For reference types (objects), `==` and `!=` compare references, not contents. Two `String` objects with the same characters can still compare as unequal with `==` because they live at different addresses.\n\n\n```java\npublic class CompareValues {\n public static void main(String[] args) {\n int cartSize = 3;\n int freeShippingThreshold = 5;\n boolean qualifies = cartSize >= freeShippingThreshold;\n System.out.println(\"Free shipping: \" + qualifies);\n\n String coupon1 = new String(\"SAVE10\");\n String coupon2 = new String(\"SAVE10\");\n System.out.println(coupon1 == coupon2);\n System.out.println(coupon1.equals(coupon2));\n }\n}\n```\n\n\nUse `==` for primitives. Use `.equals()` for objects when you care about content equality.\n\n---\n\n# Logical Operators\n\nLogical operators combine `boolean` values. There are three: `&&` (AND), `||` (OR), and `!` (NOT).\n\n\n| Operator | Name | Example | Result |\n| -------- | ---- | ---------------- | ---------------------------------- |\n| `&&` | AND | `a && b` | `true` if both are `true` |\n| `\\|\\|` | OR | `a \\|\\| b` | `true` if at least one is `true` |\n| `!` | NOT | `!a` | Flips `true` to `false` and back |\n\n\n\n```java\npublic class CheckoutEligibility {\n public static void main(String[] args) {\n int cartItems = 2;\n boolean hasCoupon = true;\n boolean canCheckout = cartItems > 0 && hasCoupon;\n System.out.println(\"Can check out: \" + canCheckout);\n }\n}\n```\n\n\n### Short-Circuit Evaluation\n\nBoth `&&` and `||` are **short-circuit** operators. They evaluate the left side first, and skip the right side if the answer is already determined.\n\n- For `&&`, if the left side is `false`, the whole expression is `false`, so the right side is never evaluated.\n- For `||`, if the left side is `true`, the whole expression is `true`, so the right side is never evaluated.\n\n\n```mermaid\nflowchart TD\n A[Evaluate left operand]:::cyan --> B{Operator?}:::orange\n B -- \"&&\" --> C{Left is true?}:::orange\n B -- \"\\|\\|\" --> D{Left is false?}:::orange\n C -- Yes --> E[Evaluate right operand]:::teal\n C -- No --> F[Result: false
Skip right]:::red\n D -- Yes --> E\n D -- No --> G[Result: true
Skip right]:::green\n E --> H[Return right's value]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThis is more than a performance optimization. It enables guarding against errors. A common pattern is checking for `null` before calling a method on an object:\n\n\n```java\npublic class SafeAccess {\n public static void main(String[] args) {\n String customer = null;\n boolean isVip = customer != null && customer.equals(\"VIP\");\n System.out.println(\"Is VIP: \" + isVip);\n }\n}\n```\n\n\nIf `customer` is `null`, the left side `customer != null` is `false`, so `&&` short-circuits and never calls `customer.equals(...)`. Without short-circuiting, that call would throw `NullPointerException`.\n\n---\n\n# Bitwise and Non-Short-Circuit Operators\n\nBitwise operators work on the individual bits of an integer. They aren't used every day, but they show up in flag handling, low-level math, and a few performance tricks.\n\n\n| Operator | Name | Example | Result |\n| -------- | --------------------- | ----------- | --------------- |\n| `&` | Bitwise AND | `0b1100 & 0b1010` | `0b1000` (`8`) |\n| `\\|` | Bitwise OR | `0b1100 \\| 0b1010` | `0b1110` (`14`) |\n| `^` | Bitwise XOR | `0b1100 ^ 0b1010` | `0b0110` (`6`) |\n| `~` | Bitwise NOT (flip) | `~5` | `-6` |\n| `<<` | Left shift | `5 << 2` | `20` |\n| `>>` | Signed right shift | `-20 >> 2` | `-5` |\n| `>>>` | Unsigned right shift | `-20 >>> 2` | A large positive number |\n\n\n\n```java\npublic class BitwiseDemo {\n public static void main(String[] args) {\n int a = 12; // 0000 1100\n int b = 10; // 0000 1010\n System.out.println(\"a & b = \" + (a & b));\n System.out.println(\"a | b = \" + (a | b));\n System.out.println(\"a ^ b = \" + (a ^ b));\n System.out.println(\"~a = \" + (~a));\n System.out.println(\"a << 2 = \" + (a << 2));\n System.out.println(\"a >> 1 = \" + (a >> 1));\n }\n}\n```\n\n\nThe shift operators are worth a closer look. `a << 2` shifts the bits of `a` left by 2 positions, which is equivalent to multiplying by 4. `a >> 1` shifts right by 1, which is dividing by 2 and rounding down. `>>>` is the same as `>>` for positive numbers, but it fills the new high bits with zeros instead of copying the sign bit, so the result is always non-negative.\n\n### `&` and `|` on Booleans\n\nAn important detail: `&` and `|` also work on `boolean` values, but they **do not short-circuit**. They always evaluate both sides.\n\n\n```java\npublic class NonShortCircuit {\n public static void main(String[] args) {\n String customer = null;\n try {\n boolean isVip = customer != null & customer.equals(\"VIP\");\n System.out.println(\"Is VIP: \" + isVip);\n } catch (NullPointerException e) {\n System.out.println(\"Crashed: NullPointerException\");\n }\n }\n}\n```\n\n\nThe single `&` evaluates both sides regardless of the left result, so `customer.equals(\"VIP\")` runs on a `null` reference. Use `&&` and `||` for boolean logic unless both sides specifically need to evaluate (for example, because the right side has a side effect that must run).\n\n---\n\n# Assignment Operators\n\nThe basic assignment is `=`. The compound forms combine an arithmetic or bitwise operation with assignment, so `total += tax` is shorthand for `total = total + tax`.\n\n\n| Operator | Equivalent | Example |\n| -------- | ---------------- | ---------- |\n| `=` | Plain assignment | `x = 5` |\n| `+=` | `x = x + y` | `x += 3` |\n| `-=` | `x = x - y` | `x -= 3` |\n| `*=` | `x = x * y` | `x *= 2` |\n| `/=` | `x = x / y` | `x /= 2` |\n| `%=` | `x = x % y` | `x %= 5` |\n| `&=` | `x = x & y` | `x &= 0b1` |\n| `\\|=` | `x = x \\| y` | `x \\|= 0b1` |\n| `^=` | `x = x ^ y` | `x ^= 0b1` |\n| `<<=` | `x = x << y` | `x <<= 2` |\n| `>>=` | `x = x >> y` | `x >>= 2` |\n\n\n\n```java\npublic class RunningTotal {\n public static void main(String[] args) {\n double total = 0;\n total += 19.99;\n total += 9.99;\n total += 4.50;\n total *= 1.08;\n System.out.println(\"Final total: $\" + total);\n }\n}\n```\n\n\nCompound assignments include an implicit cast back to the variable's type. That means `byte b = 10; b += 200;` compiles even though `b = b + 200;` would not (because `b + 200` is an `int`, and assigning an `int` to a `byte` needs an explicit cast). The compound form inserts the cast automatically, and the value wraps around just like any narrowing cast. Be aware of this when working with `byte` and `short`.\n\n\n```java\npublic class CompoundCast {\n public static void main(String[] args) {\n byte count = 10;\n count += 200;\n System.out.println(\"count: \" + count);\n }\n}\n```\n\n\n---\n\n# Ternary Operator\n\nThe ternary operator `condition ? a : b` picks between two values based on a boolean. If `condition` is `true`, the expression evaluates to `a`; otherwise to `b`. It is the only operator in Java that takes three operands.\n\n\n```java\npublic class DiscountRate {\n public static void main(String[] args) {\n boolean isPremium = true;\n int discount = isPremium ? 20 : 5;\n System.out.println(\"Discount: \" + discount + \"%\");\n }\n}\n```\n\n\nTernary is useful when assigning one of two values to a variable in a single line. It keeps simple decisions compact. Avoid nesting ternaries inside other ternaries; readability degrades quickly:\n\n\n```java\nString tier = isPremium ? \"Gold\" : isLoyal ? \"Silver\" : \"Bronze\";\n```\n\n\nThat works, but it slows readers down. A plain `if`-`else if`-`else` chain is easier to follow. Save ternary for the cases where both branches are short and obvious.\n\n---\n\n# The `instanceof` Operator\n\n`instanceof` checks whether an object is an instance of a particular type. It returns `true` or `false`.\n\n\n```java\npublic class InstanceofDemo {\n public static void main(String[] args) {\n Object item = \"Wireless Headphones\";\n System.out.println(item instanceof String);\n System.out.println(item instanceof Integer);\n }\n}\n```\n\n\n`instanceof` is commonly used when a reference of one type might point to an actual object of a more specific subtype. It comes up in inheritance, polymorphism, and pattern matching.\n\n---\n\n# Operator Precedence and Associativity\n\nWhen an expression mixes several operators, Java evaluates them in a specific order. **Precedence** decides which operator binds tighter; **associativity** decides what happens when two operators of the same precedence sit next to each other.\n\nThe table below lists the families from highest to lowest precedence. Operators in the same row have the same precedence.\n\n\n| Rank | Operators | Description | Associativity |\n| ---- | ------------------------------- | ---------------------------- | ------------- |\n| 1 | `++ -- + - ! ~ (type)` | Unary, cast | Right to left |\n| 2 | `* / %` | Multiplicative | Left to right |\n| 3 | `+ -` | Additive (and concatenation) | Left to right |\n| 4 | `<< >> >>>` | Shift | Left to right |\n| 5 | `< > <= >= instanceof` | Relational | Left to right |\n| 6 | `== !=` | Equality | Left to right |\n| 7 | `&` | Bitwise AND | Left to right |\n| 8 | `^` | Bitwise XOR | Left to right |\n| 9 | `\\|` | Bitwise OR | Left to right |\n| 10 | `&&` | Logical AND | Left to right |\n| 11 | `\\|\\|` | Logical OR | Left to right |\n| 12 | `? :` | Ternary | Right to left |\n| 13 | `= += -= *= /= %= &= \\|= ^= <<= >>= >>>=` | Assignment | Right to left |\n\n\nA worked example using several of these:\n\n\n```java\npublic class PrecedenceDemo {\n public static void main(String[] args) {\n int subtotal = 100;\n int tax = 8;\n int shipping = 5;\n boolean isPremium = true;\n int total = subtotal + tax + (isPremium ? 0 : shipping);\n System.out.println(\"Total: \" + total);\n }\n}\n```\n\n\nJava reads `subtotal + tax + (isPremium ? 0 : shipping)` as follows:\n\n1. Parentheses force the ternary to evaluate first. `isPremium` is `true`, so the ternary gives `0`.\n2. With the parentheses replaced, the expression becomes `subtotal + tax + 0`.\n3. `+` is left associative, so it evaluates as `(subtotal + tax) + 0`, which is `108`.\n\nWithout the parentheses, the ternary's low precedence would have caused a problem: `subtotal + tax + isPremium ? 0 : shipping` would parse as `((subtotal + tax) + isPremium) ? 0 : shipping`, which doesn't compile because an `int` cannot be added to a `boolean`.\n\n### Use Parentheses for Clarity\n\nMemorizing the precedence rules isn't typically required. The easier approach: add parentheses whenever the order of operations isn't obvious at a glance. They make intent explicit and save the reader from looking up the table.\n\n\n```java\nboolean qualifies = (cart.size() > 0) && (hasCoupon || isPremium);\n```\n\n\nThat version reads cleanly even without remembering whether `&&` binds tighter than `||`. The compiler accepts both, but readability matters.","pageType":"java"}

Operators

Get Premium