The JavaTM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search

Trail: Learning the Java Language
Lesson: The Nuts and Bolts of the Java Language

## 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