Java Operators Explained — Types, Examples and Beginner Mistakes
Every useful program ever written does one of three things: it calculates something, it makes a decision, or it does both. When you open a banking app and it shows your balance after a purchase, that's subtraction. When Netflix decides whether to show you a 'Kids Mode' option based on your account type, that's a comparison. Every single one of those actions is powered by operators — and they're arguably the most fundamental tool in any Java developer's toolbox.
Arithmetic Operators — Java as Your Personal Calculator
Arithmetic operators do exactly what they sound like — they perform maths. Java gives you six of them: addition (+), subtraction (-), multiplication (*), division (/), modulus (%), and the increment/decrement shortcuts (++ and --). You already know the first four from school. The one that surprises beginners is the modulus operator (%). It gives you the remainder after division. So 10 % 3 gives you 1, because 10 divided by 3 is 3 with 1 left over. This is incredibly useful in real programs — for example, checking if a number is even or odd by seeing if number % 2 equals zero. The increment operator (++) simply adds 1 to a variable. Writing score++ is identical to writing score = score + 1, just shorter and cleaner. You'll use this constantly inside loops. The decrement operator (--) does the opposite — subtracts 1. One subtle thing: there's a difference between ++score (pre-increment) and score++ (post-increment) when you use them inside expressions. We'll cover that in the Gotchas section — it trips up almost everyone at first.
public class ArithmeticOperatorsDemo { public static void main(String[] args) { int totalPrice = 250; // starting price in pence int discountAmount = 30; // discount to apply int numberOfItems = 3; // items in the basket // Basic arithmetic — works exactly like a calculator int priceAfterDiscount = totalPrice - discountAmount; System.out.println("Price after discount: " + priceAfterDiscount); // 220 int totalForAllItems = priceAfterDiscount * numberOfItems; System.out.println("Total for all items: " + totalForAllItems); // 660 // Integer division — IMPORTANT: both values are int, so result is also int // Any decimal part is simply dropped (not rounded) int sharePerPerson = totalForAllItems / 2; System.out.println("Each person pays: " + sharePerPerson); // 330 // Modulus — gives us the REMAINDER after division // Great for checking even/odd, or wrapping values int leftoverPence = totalForAllItems % 7; System.out.println("Remainder when split 7 ways: " + leftoverPence); // 2 // Checking if a number is even — a classic modulus use case int quantity = 8; if (quantity % 2 == 0) { System.out.println(quantity + " is an even number"); // prints this } // Increment — adds 1 to the variable, shorter than writing score = score + 1 int score = 10; score++; // score is now 11 System.out.println("Score after increment: " + score); // 11 // Decrement — subtracts 1 int livesRemaining = 3; livesRemaining--; // livesRemaining is now 2 System.out.println("Lives remaining: " + livesRemaining); // 2 } }
Total for all items: 660
Each person pays: 330
Remainder when split 7 ways: 2
8 is an even number
Score after increment: 11
Lives remaining: 2
Relational and Logical Operators — Teaching Java to Make Decisions
If arithmetic operators are the calculator, relational operators are the judge. They compare two values and return a boolean — either true or false. That's it. There are six of them: == (equals), != (not equals), > (greater than), < (less than), >= (greater than or equal to), and <= (less than or equal to). Notice that equality uses TWO equals signs (==), not one. A single = means assignment (you're setting a value). Two == means comparison (you're asking a question). This is one of the most common beginner mistakes in any language. Logical operators let you chain those comparisons together. AND (&&) means both conditions must be true. OR (||) means at least one must be true. NOT (!) flips a boolean — true becomes false and vice versa. Think of && like a nightclub bouncer checking two ID criteria at once: 'Are you over 18 AND do you have valid ID?' Both must pass. Think of || like a door that opens if you have a keycard OR you know the code — either one is enough. These are the backbone of every if-statement, every loop condition, and every business rule your programs will ever implement.
public class RelationalAndLogicalDemo { public static void main(String[] args) { int userAge = 20; boolean hasValidMembership = true; double accountBalance = 150.75; double minimumRequired = 100.00; // --- RELATIONAL OPERATORS --- // Each comparison produces a boolean: true or false boolean isAdult = userAge >= 18; System.out.println("Is user an adult? " + isAdult); // true boolean balanceIsSufficient = accountBalance > minimumRequired; System.out.println("Balance sufficient? " + balanceIsSufficient); // true boolean isExactlyTwenty = userAge == 20; System.out.println("Is user exactly 20? " + isExactlyTwenty); // true boolean isNotTwenty = userAge != 20; System.out.println("Is user NOT 20? " + isNotTwenty); // false // --- LOGICAL OPERATORS --- // && (AND) — BOTH sides must be true for the result to be true // Real use: user can access premium content only if adult AND has membership boolean canAccessPremiumContent = isAdult && hasValidMembership; System.out.println("Can access premium content? " + canAccessPremiumContent); // true // || (OR) — AT LEAST ONE side must be true // Real use: show warning if balance is low OR membership has expired boolean membershipExpired = false; boolean showWarning = !balanceIsSufficient || membershipExpired; System.out.println("Show account warning? " + showWarning); // false // ! (NOT) — flips the boolean value boolean isLoggedOut = !hasValidMembership; // hasValidMembership is true, so this is false System.out.println("Is user logged out? " + isLoggedOut); // false // Combining everything — a realistic access check if (isAdult && hasValidMembership && balanceIsSufficient) { System.out.println("Access granted — welcome to the platform!"); } else { System.out.println("Access denied — check your account."); } } }
Balance sufficient? true
Is user exactly 20? true
Is user NOT 20? false
Can access premium content? true
Show account warning? false
Is user logged out? false
Access granted — welcome to the platform!
Assignment and Compound Assignment Operators — Writing Less, Doing More
The basic assignment operator (=) stores a value into a variable. You've already seen it: int score = 10. That's it doing its job. But Java also gives you compound assignment operators, which combine an arithmetic operation with assignment in one step. Instead of writing totalScore = totalScore + 50, you write totalScore += 50. They're shorthand — nothing more, nothing less. The full set is: += (add and assign), -= (subtract and assign), *= (multiply and assign), /= (divide and assign), and %= (modulus and assign). Beyond being shorter to type, they're also clearer to read. When a teammate sees totalScore += 50 they instantly know you're adding to an existing value — they don't have to parse both sides of a longer expression to figure that out. There's also the ternary operator (?:), which is a compact way to write a simple if-else in a single line. It looks unusual at first, but once it clicks, you'll use it constantly for concise value assignment. The structure is: condition ? valueIfTrue : valueIfFalse. Think of it as asking a yes/no question inline: 'Is the temperature above 25? If yes, use sunscreen; if no, use a jacket'.
public class AssignmentOperatorsDemo { public static void main(String[] args) { int playerScore = 100; // basic assignment — storing 100 into playerScore // Compound assignment operators — shorthand for common operations playerScore += 50; // same as: playerScore = playerScore + 50 System.out.println("After bonus points: " + playerScore); // 150 playerScore -= 20; // same as: playerScore = playerScore - 20 System.out.println("After penalty: " + playerScore); // 130 playerScore *= 2; // same as: playerScore = playerScore * 2 (double multiplier active) System.out.println("After double multiplier: " + playerScore); // 260 playerScore /= 4; // same as: playerScore = playerScore / 4 System.out.println("After score divided: " + playerScore); // 65 playerScore %= 10; // same as: playerScore = playerScore % 10 (keep only the ones digit) System.out.println("Remainder kept: " + playerScore); // 5 // --- TERNARY OPERATOR --- // Structure: condition ? valueIfTrue : valueIfFalse // Think of it as a one-line if-else for simple value decisions int temperature = 28; // Standard if-else version (verbose): // String advice; // if (temperature > 25) { advice = "wear sunscreen"; } // else { advice = "bring a jacket"; } // Ternary version (clean and concise): String weatherAdvice = (temperature > 25) ? "wear sunscreen" : "bring a jacket"; System.out.println("Weather advice: " + weatherAdvice); // wear sunscreen // Another real-world example — labelling a value int cartItemCount = 1; String itemLabel = (cartItemCount == 1) ? "item" : "items"; System.out.println("You have " + cartItemCount + " " + itemLabel + " in your cart."); // Output: You have 1 item in your cart. } }
After penalty: 130
After double multiplier: 260
After score divided: 65
Remainder kept: 5
Weather advice: wear sunscreen
You have 1 item in your cart.
Operator Precedence — Why Java Doesn't Always Calculate Left to Right
Here's something that surprises almost every beginner: Java doesn't always evaluate operators from left to right. It follows operator precedence — a hierarchy of which operators get calculated first, just like the BODMAS/PEMDAS rule you learned in maths class. Multiplication and division happen before addition and subtraction. Parentheses override everything. Without understanding this, you'll write expressions that produce completely unexpected results and spend hours debugging something that looks correct at first glance. The general order from highest to lowest priority is: parentheses first, then increment/decrement, then multiplication/division/modulus, then addition/subtraction, then relational comparisons, then equality checks, then logical AND, then logical OR, and finally assignment. You do not need to memorise this entire list right now. The practical rule that will save you 95% of the time is this: when in doubt, use parentheses. They make your intent crystal clear to both Java and to anyone reading your code later. Explicit is always better than clever when it comes to operator precedence.
public class OperatorPrecedenceDemo { public static void main(String[] args) { // --- WITHOUT PARENTHESES — precedence decides the order --- // Multiplication happens BEFORE addition, just like in maths int resultWithoutBrackets = 2 + 3 * 4; // Java calculates: 2 + (3 * 4) = 2 + 12 = 14 System.out.println("Without brackets: " + resultWithoutBrackets); // 14 // --- WITH PARENTHESES — you control the order --- int resultWithBrackets = (2 + 3) * 4; // Java calculates: (5) * 4 = 20 System.out.println("With brackets: " + resultWithBrackets); // 20 // Real-world example: calculating a discount correctly double originalPrice = 200.0; double discountPercent = 10.0; double shippingCost = 15.0; // WRONG — precedence causes a bug here: // Java calculates: 200.0 - (10.0 / 100.0 * 200.0) + 15.0 // That's actually correct here, but watch what happens when intent is ambiguous // CLEAR — parentheses show exactly what you intend: double discountAmount = (discountPercent / 100.0) * originalPrice; // 20.0 double finalPrice = originalPrice - discountAmount + shippingCost; System.out.println("Discount amount: £" + discountAmount); // £20.0 System.out.println("Final price: £" + finalPrice); // £195.0 // --- RELATIONAL before LOGICAL in precedence --- int userAge = 22; double userBalance = 80.0; // This works correctly because > and < are evaluated BEFORE && // So Java reads it as: (userAge > 18) && (userBalance > 50.0) boolean isEligible = userAge > 18 && userBalance > 50.0; System.out.println("User is eligible: " + isEligible); // true // Pre-increment vs post-increment — a precedence-related gotcha int counter = 5; int postIncrementResult = counter++; // counter's CURRENT value (5) is assigned, THEN counter becomes 6 System.out.println("Post-increment result: " + postIncrementResult); // 5 System.out.println("Counter after post-increment: " + counter); // 6 int preIncrementResult = ++counter; // counter becomes 7 FIRST, then 7 is assigned System.out.println("Pre-increment result: " + preIncrementResult); // 7 System.out.println("Counter after pre-increment: " + counter); // 7 } }
With brackets: 20
Discount amount: £20.0
Final price: £195.0
User is eligible: true
Post-increment result: 5
Counter after post-increment: 6
Pre-increment result: 7
Counter after pre-increment: 7
| Operator Type | Symbols | Returns | Primary Use Case |
|---|---|---|---|
| Arithmetic | + - * / % ++ -- | A number (int, double, etc.) | Calculations — totals, scores, discounts |
| Relational | == != > < >= <= | boolean (true/false) | Comparisons — is X bigger than Y? |
| Logical | && || ! | boolean (true/false) | Chaining conditions — AND/OR/NOT logic |
| Assignment | = += -= *= /= %= | The assigned value | Storing or updating variable values |
| Ternary | ? : | Either of two values | Concise if-else for single value decisions |
🎯 Key Takeaways
- The modulus operator (%) returns the remainder after division — number % 2 == 0 is the canonical way to check if a number is even, and it's used in real code everywhere from pagination to round-robin load balancing.
- Integer division silently drops decimals in Java — 7 / 2 is 3, not 3.5. Cast to double when you need precision: (double) 7 / 2 gives 3.5.
- == compares primitive values correctly, but for objects (especially Strings) it checks reference identity, not content equality. That's a separate deep-dive, but knowing == has this limitation starts here.
- Parentheses have zero performance cost and massively improve readability — use them whenever operator precedence might not be obvious to the next person reading your code, which is often future you.
⚠ Common Mistakes to Avoid
- ✕Mistake 1: Using = instead of == in a comparison — Writing if (score = 10) instead of if (score == 10) causes a compile error in Java (unlike some languages where it silently sets the value). The fix: always use == when asking 'are these equal?' and = only when assigning a value. If you're ever unsure, flip the comparison to if (10 == score) — a constant on the left means if you accidentally write =, Java will error immediately since you can't assign to a literal.
- ✕Mistake 2: Integer division silently discarding decimals — Writing int result = 7 / 2 and expecting 3.5, but getting 3 instead with no warning or error. The fix: if you need a decimal result, make at least one operand a double — either declare it as double or cast it: (double) 7 / 2 or 7.0 / 2. Always use double for financial, scientific, or percentage calculations.
- ✕Mistake 3: Confusing post-increment and pre-increment inside expressions — Writing int result = counter++ and being surprised that result holds the old value of counter, not the incremented one. Post-increment (counter++) returns the current value and THEN increments. Pre-increment (++counter) increments FIRST and THEN returns the new value. The fix: when in doubt, put the increment on its own line (counter++) and use the variable on the next line. Only combine them into a single expression once you fully understand the evaluation order.
Interview Questions on This Topic
- QWhat is the difference between == and .equals() in Java, and when would using == to compare two String objects give you a wrong answer?
- QWhat does the modulus operator (%) actually return, and can you give me a real-world use case for it beyond just checking if a number is even or odd?
- QWhat is the output of this code and why: int a = 5; int b = a++; System.out.println(a + ' ' + b); — Walk me through exactly what happens at each step.
Frequently Asked Questions
What is the difference between = and == in Java?
A single = is the assignment operator — it stores a value into a variable, like int age = 25. A double == is the equality comparison operator — it asks a yes/no question, like if (age == 25). Using = where you meant == is one of the most common beginner errors, so always double-check which one you need.
What does the % operator do in Java?
The % operator is called the modulus operator and it returns the remainder after integer division. For example, 10 % 3 gives 1 because 10 divided by 3 is 3 remainder 1. It's commonly used to check if a number is even (number % 2 == 0), to wrap a value within a range, or to distribute items evenly across groups.
Why does 7 / 2 equal 3 in Java instead of 3.5?
Because both 7 and 2 are integers (int type), and when Java divides two integers the result is also an integer — the decimal part is simply discarded without rounding. To get 3.5, you need at least one value to be a double: write 7.0 / 2 or cast it with (double) 7 / 2. This is called integer division and it catches beginners off-guard frequently.
Written and reviewed by senior developers with real-world experience across enterprise, startup and open-source projects. Every article on TheCodeForge is written to be clear, accurate and genuinely useful — not just SEO filler.