## Integer vs floating point division

Java uses the same operator, `/`

for both integer and floating point (decimal, `double`

) division. When at least 1 of the operands is of type `double`

, the operator performs floating point division. When both operands are of type `int`

, the operator performs integer division.

The result of integer divisions is an `int`

. Any decimal portion of the quotient is discarded.

### Examples

```
System.out.println(25 / 2); // prints 12
System.out.println(25.0 / 2); // prints 12.5
System.out.println(25 / 2.0); // prints 12.5
System.out.println(25.0 / 2.0); // prints 12.5
int a = 25;
int b = 2;
double c = 2; // stored as 2.0
System.out.println(a / b); // prints 12
System.out.println((double) (a / b)); // prints 12.0
// Each line below prints 12.5
System.out.println(a / c);
System.out.println((double) a / b);
System.out.println(a / (double) b);
System.out.println((double) a / (double) b);
```

The most commonly misunderstood example is `(double) (a / b)`

. This expression evaluates to `12.0`

. The division happens before the cast. Both operands are of type `int`

so integer division is peformed. The result of integer division is cast to a `double`

.

## Modular division

Modular division in Java uses the `%`

symbol. When both operands are of type `int`

and are non-negative (`>= 0`

), modular division returns the remainder from integer division.

(Modular division with floating point values and negative values is also possible. Many other resources discuss the behavior.)

### Examples

```
System.out.println(22 % 5); // prints 2
System.out.println(20 % 5); // prints 0
System.out.println(20 % 20); // prints 0
System.out.println(45 % 1234); // prints 45
System.out.println(0 % 20); // prints 0
System.out.println(20 % 0); // throws ArithmeticException
```

When a number is modularly divided by a larger number, the result is the original (smaller) number.

As with regular division, 0 can be the left operand for modular division but it cannot be the right operand. Modularly dividing by 0 results in an `ArithmeticException`

.

### Determining divisiblity

Modular division has many uses, including determining if a number is divisible by another number. The expression `a % b == 0`

evaluates to `true`

if and only if `a`

is divisible by `b`

.

### Wrapping a value

```
int val = (int) (Math.random() * 26); // 0 <= val <= 25
int k = (int) (Math.random() * 100); // 0 <= k <= 99
int newVal = (val + k) % 26; // 0 <= newVal <= 25
```

In the example above, `newVal`

will never exceed `25`

. This technique is commonly used to wrap a value when it may exceed a maximum.

`val` |
`k` |
`val + k` |
`(val + k) % 26` |
---|---|---|---|

`23` |
`1` |
`24` |
`24` |

`23` |
`2` |
`25` |
`25` |

`23` |
`3` |
`26` |
`0` |

`23` |
`4` |
`27` |
`1` |