Java Operators

An operator is a symbol that tells Java to perform an action on your data. You already know some from math class: +, -, *.

Java has several categories of operators:

• Arithmetic: Do math (+, -, *, /, %)
• Comparison: Compare values (==, !=, >, <)
• Logical: Combine true/false (&&, ||, !)
• Assignment: Store values (=, +=, -=)

Let's go through each one with examples.

These work mostly like you'd expect from math class, with one big exception:

int a = 10, b = 3;

a + b   →  13    // Addition
a - b   →  7     // Subtraction
a * b   →  30    // Multiplication
a / b   →  3     // Division (⚠️ NOT 3.33!)
a % b   →  1     // Modulo (remainder)

int result = 7 / 2;     // Result: 3 (not 3.5!)
int result2 = 1 / 3;    // Result: 0 (not 0.33!)
int result3 = 99 / 100; // Result: 0 (not 0.99!)

double result = 7.0 / 2;       // 3.5 ✅
double result2 = (double) 7 / 2; // 3.5 ✅
double result3 = 7 / 2.0;      // 3.5 ✅

The % (modulo) operator gives you the remainder after division. It seems simple, but it's incredibly powerful:

10 % 3  →  1    // 10 ÷ 3 = 3 remainder 1
7 % 2   →  1    // 7 ÷ 2 = 3 remainder 1
8 % 2   →  0    // 8 ÷ 2 = 4 remainder 0
15 % 5  →  0    // 15 ÷ 5 = 3 remainder 0

Real-world uses:

int totalSeconds = 3725;
int minutes = totalSeconds / 60;  // 62 minutes
int seconds = totalSeconds % 60;  // 5 seconds
// Answer: 62 minutes and 5 seconds

Comparison operators compare two values and return true or false. They're essential for making decisions in your programs (which you'll do in the next lesson with if statements).

int x = 5, y = 10;

x == y    →  false   // Equal to?
x != y    →  true    // Not equal to?
x > y     →  false   // Greater than?
x < y     →  true    // Less than?
x >= y    →  false   // Greater than or equal to?
x <= y    →  true    // Less than or equal to?

Real-world example:

int age = 17;
boolean canVote = age >= 18;     // false
boolean isTeenager = age >= 13 && age <= 19;  // true

double balance = 50.0;
boolean canAfford = balance >= 29.99;  // true

Logical operators let you combine multiple true/false conditions into one. There are three:

Practical example:

int age = 20;
boolean hasLicense = true;
boolean isInsured = false;

// Can this person drive?
boolean canDrive = age >= 16 && hasLicense && isInsured;
// false — all must be true, but isInsured is false

// Can they get a discount?
boolean getsDiscount = age < 18 || age > 65;
// false — neither condition is true for age 20

// Safe — won't crash if name is null!
if (name != null && name.length() > 0) {
    // Only runs if name exists AND has content
}

Instead of writing x = x + 5, Java has shortcuts:

int score = 100;

score += 10;   // score = score + 10  → 110
score -= 5;    // score = score - 5   → 105
score *= 2;    // score = score * 2   → 210
score /= 3;    // score = score / 3   → 70
score %= 6;    // score = score % 6   → 4

Pre vs Post Increment:

int a = 5;
int b = a++;   // b gets 5, THEN a becomes 6
// Post-increment: use the value first, then add 1

int c = 5;
int d = ++c;   // c becomes 6 first, THEN d gets 6
// Pre-increment: add 1 first, then use the value

Just like in math, Java has rules about which operations happen first. Multiplication happens before addition unless you use parentheses:

int result1 = 2 + 3 * 4;      // 14 (not 20!)
int result2 = (2 + 3) * 4;    // 20 (parentheses force order)

boolean check = true || false && false;  // true
// && happens before ||, so: true || (false && false) → true || false → true

Precedence from highest to lowest:

This trips up every Java beginner. With numbers, == works perfectly. With Strings, it's dangerous:

// Numbers — == works fine
int a = 5, b = 5;
a == b   →  true  ✅

// Strings — == is UNRELIABLE
String s1 = new String("hello");
String s2 = new String("hello");
s1 == s2        →  false  ❌  (comparing memory addresses!)
s1.equals(s2)   →  true   ✅  (comparing actual text!)

if (name == "Alice") {
  // May fail unexpectedly!
}

if (name.equals("Alice")) {
  // Safe and reliable!
}