The Java language provides 7 operators that perform arithmetic on integer and floating point values.

- There are two
`+`

operators:- The binary addition operator adds one number to another one. (There is also a binary
`+`

operator that performs string concatenation. That is described in a separate example.) - The unary plus operator does nothing apart from triggering numeric promotion (see below)

- The binary addition operator adds one number to another one. (There is also a binary
- There are two
`-`

operators:- The binary subtraction operator subtracts one number from another one.
- The unary minus operator is equivalent to subtracting its operand from zero.

- The binary multiply operator (*) multiplies one number by another.
- The binary divide operator (/) divides one number by another.
- The binary remainder
^{1}operator (%) calculates the remainder when one number is divided by another.

^{1. This is often incorrectly referred to as the "modulus" operator. "Remainder" is the term that is used by the JLS. "Modulus" and "remainder" are not the same thing.}

The operators require numeric operands and produce numeric results. The operand types can be any primitive numeric type (i.e. `byte`

, `short`

, `char`

, `int`

, `long`

, `float`

or `double`

) or any numeric wrapper type define in `java.lang`

; i.e. (`Byte`

, `Character`

, `Short`

, `Integer`

, `Long`

, `Float`

or `Double`

.

The result type is determined base on the types of the operand or operands, as follows:

- If either of the operands is a
`double`

or`Double`

, then the result type is`double`

. - Otherwise, if either of the operands is a
`float`

or`Float`

, then the result type is`float`

. - Otherwise, if either of the operands is a
`long`

or`Long`

, then the result type is`long`

. - Otherwise, the result type is
`int`

. This covers`byte`

,`short`

and`char`

operands as well as `int.

The result type of the operation determines how the arithmetic operation is performed, and how the operands are handled

- If the result type is
`double`

, the operands are promoted to`double`

, and the operation is performed using 64-bit (double precision binary) IEE 754 floating point arithmetic. - If the result type is
`float`

, the operands are promoted to`float`

, and the operation is performed using 32-bit (single precision binary) IEE 754 floating point arithmetic. - If the result type is
`long`

, the operands are promoted to`long`

, and the operation is performed using 64-bit signed twos-complement binary integer arithmetic. - If the result type is
`int`

, the operands are promoted to`int`

, and the operation is performed using 32-bit signed twos-complement binary integer arithmetic.

Promotion is performed in two stages:

- If the operand type is a wrapper type, the operand value is
*unboxed*to a value of the corresponding primitive type. - If necessary, the primitive type is promoted to the required type:
- Promotion of integers to
`int`

or`long`

is loss-less. - Promotion of
`float`

to`double`

is loss-less. - Promotion of an integer to a floating point value can lead to loss of precision. The conversion is performed using IEE 768 "round-to-nearest" semantics.

- Promotion of integers to

The / operator divides the left-hand operand `n`

(the *dividend*) and the right-hand operand `d`

(the *divisor*) and produces the result `q`

(the *quotient*).

Java integer division rounds towards zero. The JLS Section 15.17.2 specifies the behavior of Java integer division as follows:

The quotient produced for operands

`n`

and`d`

is an integer value`q`

whose magnitude is as large as possible while satisfying`|d ⋅ q| ≤ |n|`

. Moreover,`q`

is positive when`|n| ≥ |d|`

and`n`

and`d`

have the same sign, but`q`

is negative when`|n| ≥ |d|`

and`n`

and`d`

have opposite signs.

There are a couple of special cases:

- If the
`n`

is`MIN_VALUE`

, and the divisor is -1, then integer overflow occurs and the result is`MIN_VALUE`

. No exception is thrown in this case. - If
`d`

is 0, then `ArithmeticException is thrown.

Java floating point division has more edge cases to consider. However the basic idea is that the result `q`

is the value that is closest to satisfying `d . q = n`

.

Floating point division will never result in an exception. Instead, operations that divide by zero result in an INF and NaN values; see below.

Unlike C and C++, the remainder operator in Java works with both integer and floating point operations.

For integer cases, the result of `a % b`

is defined to be the number `r`

such that `(a / b) * b + r`

is equal to `a`

, where `/`

, `*`

and `+`

are the appropriate Java integer operators. This applies in all cases except when `b`

is zero. That case, remainder results in an `ArithmeticException`

.

It follows from the above definition that `a % b`

can be negative only if `a`

is negative, and it be positive only if `a`

is positive. Moreover, the magnitude of `a % b`

is always less than the magnitude of `b`

.

Floating point remainder operation is a generalization of the integer case. The result of `a % b`

is the remainder `r`

is defined by the mathematical relation `r = a - (b ⋅ q)`

where:

`q`

is an integer,- it is negative only if
`a / b`

is negative an positive only if`a / b`

is positive, and - its magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient of
`a`

and`b`

.

Floating point remainder can produce `INF`

and `NaN`

values in edge-cases such as when `b`

is zero; see below. It will not throw an exception.

Important note:

The result of a floating-point remainder operation as computed by

`%`

is not the sameas that produced by the remainder operation defined by IEEE 754. The IEEE 754 remainder may be computed using the`Math.IEEEremainder`

library method.

Java 32 and 64 bit integer values are signed and use twos-complement binary representation. For example, the range of numbers representable as (32 bit) `int`

-2^{31} through +2^{31} - 1.

When you add, subtract or multiple two N bit integers (N == 32 or 64), the result of the operation may be too large to represent as an N bit integer. In this case, the operation leads to *integer overflow*, and the result can be computed as follows:

- The mathematical operation is performed to give a intermediate two's-complement representation of the entire number. This representation will be larger than N bits.
- The bottom 32 or 64 bits of the intermediate representation are used as the result.

It should be noted that integer overflow does not result in exceptions under any circumstances.

Java uses IEE 754 floating point representations for `float`

and `double`

. These representations have some special values for representing values that fall outside of the domain of Real numbers:

- The "infinite" or INF values denote numbers that are too large. The
`+INF`

value denote numbers that are too large and positive. The`-INF`

value denote numbers that are too large and negative. - The "indefinite" / "not a number" or NaN denote values resulting from meaningless operations.

The INF values are produced by floating operations that cause overflow, or by division by zero.

The NaN values are produced by dividing zero by zero, or computing zero remainder zero.

Surprisingly, it is possible perform arithmetic using INF and NaN operands without triggering exceptions. For example:

- Adding +INF and a finite value gives +INF.
- Adding +INF and +INF gives +INF.
- Adding +INF and -INF gives NaN.
- Dividing by INF gives either +0.0 or -0.0.
- All operations with one or more NaN operands give NaN.

For full details, please refer to the relevant subsections of JLS 15. Note that this is largely "academic". For typical calculations, an `INF`

or `NaN`

means that something has gone wrong; e.g. you have incomplete or incorrect input data, or the calculation has been programmed incorrectly.

This modified text is an extract of the original Stack Overflow Documentation created by following contributors and released under CC BY-SA 3.0

This website is not affiliated with Stack Overflow