Java Arithmetic: Mathematical Operators With Program Examples

Java has five arithmetic operators that take two operands, plus a family of unary ones covered in the unary operators topic. For beginners the five binary ones are the whole story.

Two of these are common trip-ups for people arriving from other languages.

• Multiplication is *, not x, because x is a perfectly legal variable name in Java.

• The remainder operator is %, and it works on double as well as int, which surprises people who expect modulo to be integer-only.

This is the single most important thing on the page. If **both** operands are integers, / performs integer division and throws the fractional part away. It does not round, and it does not warn you.

int dividend = 15;
int divisor = 4;
15 / 4 as integers = 3

The truncation happens because integer division is defined as "how many whole times does the divisor fit into the dividend", and 4 fits into 15 three whole times with 3 left over. That leftover is exactly what % gives you.

int dividend = 15;
int divisor = 4;
int quotient = dividend / divisor;
// 3
int remainder = dividend % divisor;
// 3
System.out.println(quotient + " remainder " + remainder);
// 3 remainder 3
// together they reconstruct the original: 3 * 4 + 3 == 15

The fix is almost always to make one operand a floating-point value, either by writing 15.0 / 4 or by declaring the variable as double. Casting only the result, as in (double) (15 / 4), does **not** help, because the integer division has already happened by the time the cast runs.

Dividing by zero is an error for integers and perfectly legal for floating point. This trips up almost everyone once.

public class DivideByZero {
    public static void main(String[] args) {
        try {
            int bad = 15 / 0;
            // throws here
            System.out.println(bad);
        } catch (ArithmeticException e) {
            System.out.println("15 / 0     -> " + e.getClass().getSimpleName() + ": " + e.getMessage());
        } System.out.println("10.0 / 0.0  -> " +(10.0 / 0.0));
        System.out.println("-10.0 / 0.0 -> " +(-10.0 / 0.0));
        System.out.println("0.0 / 0.0   -> " +(0.0 / 0.0));
    }
}

The real output:

15 / 0 -> ArithmeticException: / by zero 10.0 / 0.0 -> Infinity -10.0 / 0.0 -> -Infinity 0.0 / 0.0 -> NaN

• Integer division by zero throws ArithmeticException because the answer has no mathematical meaning and there is no nearest value to return.

• Floating point division by zero follows the IEEE 754 standard and produces a special value instead. x / 0.0 gives Infinity when x is positive and -Infinity when x is negative.

• 0.0 / 0.0 is NaN, short for Not a Number, because the question has no answer at all.

There is one consequence of NaN that catches people out later, so it is worth knowing now.

double x = 0.0 / 0.0;
System.out.println(x == x);
// false!  NaN is not equal to itself
System.out.println(x != x);
// true, and also NaN

Comparing with == will never be true for NaN. The correct test is Double.isNaN(x).

% gives the leftover after division, and its sign rule surprises people who learned modulo in mathematics.

**In Java the result takes the sign of the dividend**, the number on the left, not the divisor on the right.

dividend % divisor -7 % 3 = -1 dividend negative -> result negative 7 % -3 = 1 dividend positive -> result positive -7 % -3 = -1 dividend negative -> result negative 7 % 3 = 1 both positive -> result positive

This matches truncating integer division: -7 / 3 is -2, and -2 * 3 is -6, so the remainder must be -1 to bring the total back to -7. Mathematicians usually define modulo to follow the divisor instead, so 7 % -3 is 1 in Java but 4 in pure mathematics. This is a genuine difference between the two, not a Java bug.

System.out.println(7 / 3);
//  2
System.out.println(7 % 3);
//  1   and 2 * 3 + 1 == 7
System.out.println(-7 / 3);
// -2   truncated towards zero, not -3
System.out.println(-7 % 3);
// -1   so that -2 * 3 + -1 == -7

That second pair is worth memorising, because truncating towards zero is the opposite of what a maths textbook does. Note that % is not limited to integers; 5.5 % 2.0 is legal and gives 1.5.

Java has eight primitive numeric types, but arithmetic on byte, short and char is always carried out in int. The result is an int, and it never quietly becomes a byte again.

the promotion rule for binary arithmetic

   byte   ->  int      short  ->  int      char   ->  int
                                     |
                                     +--> everything below
                                     |
   int  ->  int      long  ->  long      float  ->  float      double -> double

   if either side is a double, the whole expression is a double
   otherwise if either side is a float, the whole expression is a float
   otherwise if either side is a long, the whole expression is a long
   otherwise everything is an int

Here is the whole ladder printed by one small program, using getClass() so nothing is guesswork.

public class Promotion {
    public static void main(String[] args) {
        byte b = 10;
        short s = 20;
        char c = 'A';
        int i = 30;
        long L = 40L;
        float f = 1.5f;
        double d = 2.5;
        show("byte + byte", b + b);
        show("short + byte", s + b);
        show("char + char", c + c);
        show("int + long", i + L);
        show("long + float", L + f);
        show("int + double", i + d);
        show("float + double", f + d);
    } static void show(String label, Object value) {
        System.out.printf("%-14s = %-8s  type %s%n", label, value, value.getClass().getSimpleName());
    }
}

byte + byte = 20 type Integer short + byte = 30 type Integer char + char = 130 type Integer int + long = 70 type Long long + float = 41.5 type Float int + double = 32.5 type Double float + double = 4.0 type Double

• byte + byte gives an Integer, never a Byte. This is exactly why byte c = b + b; fails to compile and needs (byte) written for you, which is the implicit cast discussed in the assignment topic.

• char promotes to int, so 'A' + 'A' is 130 and the character sum is a number, not text. To get a character back you must cast: (char) ('A' + 1) is 'B'.

• long promotes to float, not the other way round, so a long + float gives a Float even though a long can hold far bigger numbers. This loses precision.

• float + double is a Double, because a double is the widest type in the language and it wins.

If you have used JavaScript or Python you may already know this one, but it is worth seeing in Java because double is the default type for decimal literals.

public class Precision {
    public static void main(String[] args) {
        System.out.println("0.1 + 0.2 = " +(0.1 + 0.2));
        System.out.println("is it == 0.3 ? " +((0.1 + 0.2) == 0.3));
        System.out.println("0.1f + 0.2f = " +(0.1f + 0.2f));
    }
}

0.1 + 0.2 = 0.30000000000000004 is it == 0.3 ? false 0.1f + 0.2f = 0.3

The reason is that a double stores values in binary, and 0.1 has no exact binary representation, just as one third does not. The stored value is extremely close, and adding the two slightly-wrong approximations lands just above 0.3. Printing shows all seventeen digits, so the error is visible.

Two more precision facts worth knowing:

• float has roughly 7 significant digits and double roughly 15 to 17, so float loses the error sooner. That is why 0.1f + 0.2f prints a tidy 0.3: the answer is wrong in the same direction, it just has too few digits left to show it.

• A float cannot represent every int. (float) 16777217 prints 1.6777216E7, which is not the number you started with. The fix is to convert the other way, to double, which can hold every int exactly.

For money, never use double. Use BigDecimal, or store an amount of cents as a long.

import java.math.BigDecimal;
BigDecimal total = new BigDecimal("0.10").add(new BigDecimal("0.20"));
System.out.println(total);
// 0.30, exactly
System.out.println(total.compareTo(new BigDecimal("0.30")) == 0);
// true

Note the string constructor. Writing new BigDecimal(0.1) imports the same binary approximation error you were trying to escape.

Arithmetic on int and long wraps around rather than throwing, so a calculation that grows too large quietly produces a wrong answer. The full treatment is in the assignment topic, but it belongs here too because it is arithmetic behaviour.

int big = 2000000000;
int doubled = big * 2;
// wraps to a negative number
System.out.println(doubled);
// -294967296

For money, byte counts, or anything read from a file, use a wider type or ask for a check.

int a = 2000000000;
int safe = Math.addExact(a, a);
// throws ArithmeticException on overflow

The + operator does double duty. If **either** operand is a String, the operation becomes text concatenation and no numeric addition happens at all. The evaluation is left to right, which produces results that look like bugs.

"Score: " + 10 + 20 step 1: "Score: " + 10 -> "Score: 10"(a String is now involved) step 2: "Score: 10" + 20 -> "Score: 1020"(so 20 is appended, not added) 10 + 20 + " Score" step 1: 10 + 20 -> 30(both are numbers, so it adds) step 2: 30 + " Score" -> "30 Score"(now it concatenates)

System.out.println("Score: " + 10 + 20);
// Score: 1020
System.out.println(10 + 20 + " Score");
// 30 Score
System.out.println(1 + 2 + "x");
// 3x
System.out.println("x" + 1 + 2);
// x12

To get the arithmetic answer you have to force it before the String appears, either with parentheses or by converting the number first.

System.out.println("Score: " +(10 + 20));
// Score: 30
System.out.println("Score: " + 10 +(20 + 0));
// Score: 30
System.out.println("Score: " + String.valueOf(10 + 20));
// Score: 30

The parentheses are the cleanest option and the one to reach for by default.

The compound forms from the assignment topic, +=, -=, *=, /= and %=, work with arithmetic and save repeating the variable. They are not separate arithmetic operators, just shorthands.

int n = 20;
n += 5;
// 25
n -= 3;
// 22
n *= 2;
// 44
n /= 4;
// 11
n %= 4;
//  3
System.out.println(n);
// 3

Because the division is still integer division, n /= 4 truncates just as / would.

Multiplication and remainder bind more tightly than addition and subtraction, and all of them bind more tightly than assignment. Parentheses override all of it, so use them whenever the intent is not obvious.

System.out.println(2 + 3 * 4);
// 14, not 20
System.out.println((2 + 3) * 4);
// 20
System.out.println(10 - 4 - 3);
// 3, subtraction is left to right
System.out.println(10 -(4 - 3));
// 9

The full table, including the comparison and logical operators, is in the operator precedence topic.

Arithmetic in Java looks simple and then surprises you twice: once because / quietly discards the remainder when both sides are integers, and once because + quietly becomes text as soon as a String is involved. Everything else on this page is detail hanging off those two rules, along with the promotion of small types to int and the fact that neither division by zero nor overflow always tells you loudly that something went wrong.