Start of Tutorial > Start of Trail > Start of Lesson

Search

Arithmetic Operators

The Java language supports various arithmetic operators for all floating-point and integer numbers. These include + (addition), - (subtraction), * (multiplication), / (division), and % (modulo). For example, you can use this Java code to add two numbers:

addThis + toThis

Or you can use the following Java code to compute the remainder that results from dividing divideThis by byThis:

divideThis % byThis

This table summarizes Java's binary arithmetic operations:

Operator	Use	Description
+	op1 + op2	Adds op1 and op2
-	op1 - op2	Subtracts op2 from op1
*	op1 * op2	Multiplies op1 by op2
/	op1 / op2	Divides op1 by op2
%	op1 % op2	Computes the remainder of dividing op1 by op2

---

Note:  The Java language extends the definition of the + operator to include string concatenation. You'll see more about this in Arrays and Strings.

---

The + and - operators have unary versions that perform the following operations:

Operator	Use	Description
+	+op	Promotes op to int if it's a byte, short, or char
-	-op	Arithmetically negates op

There also are two short cut arithmetic operators, ++ which increments its operand by 1, and -- which decrements its operand by 1. Either ++ or -- can appear before (prefix) or after (postfix) its operand. The prefix version, ++op/--op, evaluates to the value of the operand after the increment/decrement operation. The postfix version, op++/op--, evaluates the value of the operand before the increment/decrement operation.

Recall the Sort program.

public class Sort {
    public static void main(String[] args) {
        int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076,
                              2000, 8, 622, 127 };

        for (int i = arrayOfInts.length; --i >= 0; ) {
            for (int j = 0; j < i; j++) {
                if (arrayOfInts[j] > arrayOfInts[j+1]) {
                    int temp = arrayOfInts[j];
                    arrayOfInts[j] = arrayOfInts[j+1];
                    arrayOfInts[j+1] = temp;
                }
            }
        }

        for (int i = 0; i < arrayOfInts.length; i++) {
            System.out.print(arrayOfInts[i] + " ");
        }
        System.out.println();
    }
}

Let's look at how the Sort program uses -- to control the outer of its two nested sorting loops. Here's the statement that controls the outer loop:

for (int i = arrayOfInts.length; --i >= 0; ) {
    ...
}

The return value of the operation --i is compared to 0 to determine whether to terminate the loop. Using the prefix version of -- means that the last iteration of this loop occurs when i is equal to 0. If we changed the code to use the postfix version of --, the last iteration of this loop occurs when i is equal to -1, which is incorrect for this program.

The other two loops in the program use the the postfix version of ++. In both cases, the version used doesn't really matter because the value returned by the operator isn't used for anything.

The short cut increment/decrement operators are summarized in the following table:

Operator	Use	Description
++	op++	Increments op by 1; evaluates to the value of op before it was incremented
++	++op	Increments op by 1; evaluates to the value of op after it was incremented
--	op--	Decrements op by 1; evaluates to the value of op before it was decremented
--	--op	Decrements op by 1; evaluates to the value of op after it was decremented

Start of Tutorial > Start of Trail > Start of Lesson

Search