Operators in Java Explained (with Examples)

Now that you can store data in variables, let's make your programs actually do things with that data — add it, compare it, and make decisions with it. That's what operators are for. They're the symbols that perform operations on values, and you already know most of them from basic maths.

1. Arithmetic operators

These do the maths you'd expect:

Two things beginners trip on:

• Integer division truncates. 10 / 3 is 3, not 3.33 — because both are int. To get decimals, use a double: 10.0 / 3 → 3.33.
• % gives the remainder. It's incredibly handy — e.g. n % 2 == 0 checks if n is even.

2. Assignment operators

= assigns a value. The others are handy shortcuts:

int x = 10;
x += 5;   // same as x = x + 5;  -> 15
x -= 3;   // x = x - 3;          -> 12
x *= 2;   // x = x * 2;          -> 24

3. Comparison (relational) operators

These compare two values and always give a boolean (true or false):

Watch out: = assigns, but == compares. Mixing them up is a classic beginner bug. (Note: for comparing text/Strings, you use .equals() instead of == — we'll cover why in a later lesson.)

4. Logical operators

These combine boolean values — essential for decisions:

• && (AND) — true only if both sides are true.
• || (OR) — true if either side is true.
• ! (NOT) — flips true to false and vice versa.

int age = 20;
boolean canVote = age >= 18 && age < 120;   // true
boolean isWeekend = false;
System.out.println(!isWeekend);            // true

5. Increment and decrement

++ adds 1 and -- subtracts 1 — you'll see these constantly, especially in loops:

int count = 5;
count++;   // now 6  (same as count = count + 1)
count--;   // now 5

A quick word on precedence

Just like in maths, operators have an order: *, /, % happen before + and -, and you can use parentheses to control the order and make your intent clear:

int result = 2 + 3 * 4;       // 14 (multiplication first)
int clear  = (2 + 3) * 4;     // 20 (parentheses first)

When in doubt, add parentheses — clearer code beats clever code.

Early on, the two bugs that caught me most were integer division (1/2 giving 0) and typing = when I meant ==. If your maths ever looks "wrong," check those two first — it's almost always one of them.

Key takeaways

• Arithmetic: + - * / %; integer division truncates, and % gives the remainder.
• Comparison operators give a boolean; = assigns while == compares.
• Logical &&, ||, ! combine booleans for decisions.
• ++/-- add or subtract 1; use parentheses to control precedence.

← Previous: Lesson 4 — Variables and Data Types
Next: Lesson 6 — Input and Output in Java (Scanner) →