Operators in Java

By the Syncfusion DevTutorials team · Last updated October 20, 2026

Use Java's arithmetic, increment, comparison, logical, assignment, ternary, bitwise and shift operators, and learn the order Java follows to evaluate an expression.

Operators are the moving parts of Java. They take values, compare them, change them, and decide what happens next.

Think of them as buttons on a calculator, switches on a control panel, and rules in a decision tree all at once.

Without operators, values just sit there. With operators, they start doing work.

What You Will Learn

In this lesson, you will learn:

1. What operators, operands, and expressions are.
2. How Java decides which part of an expression runs first.
3. How arithmetic operators work, including / and %.
4. How ++ and -- change a value by one.
5. How to compare values and combine conditions.
6. How to update a variable quickly with compound assignment.
7. How to choose between two values with the ternary operator ? :.
8. How bitwise and shift operators work on the bits of a number.

Start With a Working Example

Press Run.

Operators build a simple shopping bill

public class Main {
    public static void main(String[] args) {
        int pens = 4;
        int penPrice = 15;
        int discount = 10;

        int total = pens * penPrice - discount;
        boolean isCheap = total < 100;

        System.out.println("Total: " + total);
        System.out.println("Is it cheap? " + isCheap);
    }
}

Expected output:

Total: 50
Is it cheap? true

* multiplies, - subtracts, < compares, = stores, and + joins text with a value.

Try This

Change pens to 8. Predict both lines before you press Run.

What Is an Operator?

An operator is a symbol that tells Java to do a job on one or more values.

+ adds. > compares. = stores. Each one is an operator.

Java groups operators by the job they do:

Operands and Operators

An operand is a value that an operator works on.

In 7 + 3:

• + is the operator;
• 7 and 3 are the operands.

Operators are also grouped by how many operands they need:

• A unary operator needs one operand. Example: -5 or !isOpen.
• A binary operator needs two operands. Example: a + b.
• A ternary operator needs three operands. Java has only one: ? :.

Expressions

An expression is any piece of code that produces a value.

All of these are expressions:

42                      // a literal is an expression
price                   // a variable is an expression
price * 2               // an operator joins values into an expression
(price * 2) + shipping  // expressions can hold smaller expressions
age >= 18               // this one produces true or false

A statement is a full instruction that ends with ;. A statement often contains an expression.

int total = price * 2 + shipping;

Here the expression is price * 2 + shipping. The statement stores its value in total.

Expression Evaluation

Evaluating an expression means working out its value.

When an expression has several operators, Java needs to know which one runs first. It follows two rules: precedence and associativity.

Precedence

Precedence decides which operator goes first.

It works like school maths. Multiplication and division happen before addition and subtraction.

Multiplication happens before addition

public class Main {
    public static void main(String[] args) {
        int a = 2 + 3 * 4;
        int b = (2 + 3) * 4;

        System.out.println(a);
        System.out.println(b);
    }
}

Expected output:

14
20

In the first line, 3 * 4 happens first, giving 12. Then 2 + 12 gives 14.

In the second line, the brackets go first. 2 + 3 gives 5. Then 5 * 4 gives 20.

Brackets always win. Use them whenever the order is not obvious.

Associativity

Associativity decides the order when two operators have the same precedence.

Most operators go from left to right.

Equal precedence runs left to right

public class Main {
    public static void main(String[] args) {
        System.out.println(20 - 5 - 3);
        System.out.println(40 / 4 * 2);
    }
}

Expected output:

12
20

20 - 5 - 3 works as (20 - 5) - 3, which is 12.

40 / 4 * 2 works as (40 / 4) * 2, which is 20.

Assignment is the main exception. It goes from right to left. So a = b = 5 first stores 5 in b, then stores that in a.

Precedence Table

This table lists operators from first to last:

Arithmetic Operators

Arithmetic operators do maths.

Five arithmetic operators on the same two numbers

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));
    }
}

Expected output:

a + b = 13
a - b = 7
a * b = 30
a / b = 3
a % b = 1

Notice the brackets around (a + b). Without them, Java would join "a + b = " and a as text first. You would get a + b = 103.

Integer Division

When both operands are whole numbers, / gives a whole number. The decimal part is thrown away.

So 10 / 3 gives 3, not 3.333.

If at least one operand is a decimal, the answer is a decimal.

Whole-number division drops the decimal part

public class Main {
    public static void main(String[] args) {
        System.out.println(7 / 2);
        System.out.println(7.0 / 2);
        System.out.println((double) 7 / 2);
    }
}

Expected output:

3
3.5
3.5

7 / 2 uses two int values, so the answer is 3.

7.0 / 2 has a double, so the answer is 3.5. The cast (double) 7 does the same thing.

The Remainder Operator %

% gives what is left over after division.

Think of sharing 10 sweets between 3 friends. Each friend gets 3. One sweet is left over. So 10 % 3 is 1.

% is useful for checking if a number is even. An even number has no remainder when divided by 2.

Remainder finds even numbers and leftovers

public class Main {
    public static void main(String[] args) {
        int number = 17;
        int minutes = 135;

        System.out.println("17 is even? " + (number % 2 == 0));
        System.out.println(minutes / 60 + " hours and " + minutes % 60 + " minutes");
    }
}

Expected output:

17 is even? false
2 hours and 15 minutes

17 % 2 is 1, so 17 is not even.

135 / 60 gives the whole hours, 2. 135 % 60 gives the minutes left over, 15.

Dividing by Zero

Dividing a whole number by zero stops the program with an ArithmeticException:

int result = 10 / 0;   // ArithmeticException: / by zero

Dividing a decimal by zero does not stop the program. It gives a special value called Infinity.

Increment / Decrement

++ adds 1 to a variable. -- takes 1 away.

count++ is a short way of writing count = count + 1.

These are used a lot in loops, where you count up or down one step at a time.

Prefix and Postfix

You can put ++ before or after the variable. On its own line, both do the same thing.

The difference shows when you use them inside a bigger expression:

• Postfix x++: use the old value first, then add 1.
• Prefix ++x: add 1 first, then use the new value.

Think of a ticket machine. With postfix, you get the current ticket number, then the machine moves on. With prefix, the machine moves on first, and you get the new number.

Prefix changes first, postfix changes after

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = a++;
        System.out.println("After b = a++  ->  a = " + a + ", b = " + b);

        int c = 5;
        int d = ++c;
        System.out.println("After d = ++c  ->  c = " + c + ", d = " + d);

        int lives = 3;
        lives--;
        System.out.println("Lives left: " + lives);
    }
}

Expected output:

After b = a++  ->  a = 6, b = 5
After d = ++c  ->  c = 6, d = 6
Lives left: 2

Both a and c end up as 6.

But b got the old value, 5, because a++ hands over its value before adding 1. d got the new value, 6.

In simple words: when you use ++ on its own line, the position does not matter. Inside a bigger expression, it does.

Comparison Operators

A comparison operator compares two values. The answer is always a boolean: true or false.

They are also called relational operators.

Every comparison answers true or false

public class Main {
    public static void main(String[] args) {
        int marks = 72;
        int passMark = 40;

        System.out.println("Passed? " + (marks >= passMark));
        System.out.println("Full marks? " + (marks == 100));
        System.out.println("Not zero? " + (marks != 0));
        System.out.println("Below 50? " + (marks < 50));
    }
}

Expected output:

Passed? true
Full marks? false
Not zero? true
Below 50? false

You will use these answers in if statements and loops, to decide what the program does next.

Logical Operators

A logical operator combines true/false values into one answer.

Think of entering a cinema. You need a ticket AND you must be old enough. If either one is missing, you cannot enter.

Now think of paying. You can pay by cash OR by card. Either one works.

AND, OR and NOT combine conditions

public class Main {
    public static void main(String[] args) {
        boolean hasTicket = true;
        int age = 15;
        boolean hasCash = false;
        boolean hasCard = true;

        System.out.println("Can watch the film? " + (hasTicket && age >= 18));
        System.out.println("Can pay? " + (hasCash || hasCard));
        System.out.println("Needs a ticket? " + !hasTicket);
    }
}

Expected output:

Can watch the film? false
Can pay? true
Needs a ticket? false

hasTicket && age >= 18 is false. The ticket is fine, but 15 >= 18 is false. AND needs both.

hasCash || hasCard is true. Cash is false, but the card is true. OR needs only one.

!hasTicket flips true to false.

Truth Table

Short-Circuit Evaluation

&& and || stop as soon as they know the answer. This is called short-circuit evaluation.

• With &&, if the left side is false, the answer must be false. Java skips the right side.
• With ||, if the left side is true, the answer must be true. Java skips the right side.

This lets you guard a risky check:

The left side protects the right side from dividing by zero

public class Main {
    public static void main(String[] args) {
        int students = 0;
        int totalMarks = 0;

        boolean goodAverage = students > 0 && totalMarks / students > 50;

        System.out.println("Good average? " + goodAverage);
    }
}

Expected output:

Good average? false

students > 0 is false. So Java never runs totalMarks / students, and the program does not divide by zero.

Swap the two sides and run it again. The program now stops with an ArithmeticException, because the division runs first.

Assignment Operators

The assignment operator = stores a value in a variable.

Java also has compound assignment operators. They do a calculation and store the result in one step.

Compound assignment updates a wallet step by step

public class Main {
    public static void main(String[] args) {
        int wallet = 500;

        wallet += 200;
        System.out.println("After salary: " + wallet);

        wallet -= 150;
        System.out.println("After shopping: " + wallet);

        wallet *= 2;
        System.out.println("After doubling: " + wallet);

        wallet /= 4;
        System.out.println("After sharing: " + wallet);

        wallet %= 100;
        System.out.println("Coins left over: " + wallet);
    }
}

Expected output:

After salary: 700
After shopping: 550
After doubling: 1100
After sharing: 275
Coins left over: 75

Each line changes wallet and keeps the result in the same variable.

A Hidden Cast Inside Compound Assignment

There is one real difference between x += 5 and x = x + 5.

For small types like byte, Java turns x + 5 into an int. An int does not fit back into a byte without a cast. So the long form fails to compile:

The long form needs a cast for a byte

public class Main {
    public static void main(String[] args) {
        byte level = 10;
        level = level + 5;
        System.out.println(level);
    }
}

The compiler reports possible lossy conversion from int to byte.

The short form level += 5; compiles fine. Compound assignment adds the cast for you.

Ternary Operator

The ternary operator picks one of two values based on a condition.

condition ? valueIfTrue : valueIfFalse

Read it as a question: "Is the condition true? If yes, use the first value. If no, use the second."

One line picks between two values

public class Main {
    public static void main(String[] args) {
        int marks = 72;
        String result = marks >= 40 ? "Pass" : "Fail";

        int a = 18;
        int b = 25;
        int bigger = a > b ? a : b;

        System.out.println("Result: " + result);
        System.out.println("Bigger number: " + bigger);
    }
}

Expected output:

Result: Pass
Bigger number: 25

marks >= 40 is true, so result gets "Pass".

a > b is false, so bigger gets b, which is 25.

The ternary operator is a short form of a simple if-else. Use it for small choices. For anything longer, an if statement is easier to read.

Bitwise Operators

Inside the computer, every whole number is stored as bits. A bit is a single 0 or 1.

For example, 12 is stored as 1100, and 10 is stored as 1010.

Bitwise operators work on these bits one position at a time.

Here is 12 & 10, one column at a time:

  1100   (12)
& 1010   (10)
------
  1000   (8)

Only the leftmost column has a 1 in both numbers. So the answer is 1000, which is 8.

Bitwise operators compare numbers bit by bit

public class Main {
    public static void main(String[] args) {
        int a = 12;
        int b = 10;

        System.out.println("a & b = " + (a & b));
        System.out.println("a | b = " + (a | b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("~a    = " + (~a));
        System.out.println("a in bits: " + Integer.toBinaryString(a));
    }
}

Expected output:

a & b = 8
a | b = 14
a ^ b = 6
~a    = -13
a in bits: 1100

a | b is 1110, which is 14. a ^ b is 0110, which is 6.

~a flips every bit, including the sign bit. For any whole number, ~x equals -x - 1. So ~12 is -13.

Integer.toBinaryString() shows a number's bits as text. It is handy for checking your work.

Where Bitwise Operators Are Used

You will not use these every day. They appear in:

• settings stored as on/off flags in a single number;
• graphics and colour values;
• networking and file formats;
• fast tricks, such as x & 1, which is 1 for odd numbers and 0 for even numbers.

Shift Operators

Shift operators move all the bits of a number to the left or to the right.

Think of a row of digits on a counter. Sliding them one place to the left adds a 0 at the end. In base 10, that multiplies by 10. In bits (base 2), it multiplies by 2.

Shifting bits multiplies or divides by 2

public class Main {
    public static void main(String[] args) {
        int n = 5;

        System.out.println("5 << 1 = " + (n << 1));
        System.out.println("5 << 3 = " + (n << 3));
        System.out.println("40 >> 2 = " + (40 >> 2));
        System.out.println("-16 >> 2 = " + (-16 >> 2));
        System.out.println("-16 >>> 28 = " + (-16 >>> 28));
    }
}

Expected output:

5 << 1 = 10
5 << 3 = 40
40 >> 2 = 10
-16 >> 2 = -4
-16 >>> 28 = 15

5 is 101. Shifting left by 1 gives 1010, which is 10. Each left shift doubles the number. So 5 << 3 is 5 × 2 × 2 × 2, which is 40.

40 >> 2 halves twice, giving 10.

>> keeps negative numbers negative. So -16 >> 2 is -4.

>>> fills with zeros, even for a negative number. The sign bit becomes an ordinary bit, so the result is a large positive number. Here, -16 >>> 28 gives 15.

In simple words: x << n multiplies by 2, n times, and x >> n divides by 2, n times.

Common mistakes

The following mistakes are common when using operators. Each row shows what you see, why it happens and how to fix it.

What to Remember

• An operator does a job on operands. Together they form an expression, which produces a value.
• Java follows precedence first, then left-to-right order. Brackets always win.
• / with two whole numbers drops the decimal part. % gives the remainder.
• x++ uses the old value, then adds 1. ++x adds 1, then uses the new value.
• Comparisons give true or false. && needs both sides true, || needs one, and ! flips the value.
• +=, -= and the other compound operators update a variable in one step.
• condition ? a : b picks one of two values. Bitwise and shift operators work on the bits of a number.

Next: Conditional Statements