The **Modulo operator in Java** is quite a useful mechanism. Java provides us with basic arithmetic operators for addition, subtraction, division, multiplication etc. We can easily divide two integers in Java.

1 2 | ```
final int result = 13 / 4;
System.out.println(result);
``` |

If we execute the above code we will get a result of 3. However, what happens if we need the remainder of this operation. Well, this is what we can use the modulo operator for.

In this short tutorial we will discuss the Modulo operator in Java, and some of its use cases.

The modulo operator has some useful use cases and at times it can be a handy programming tool.

The modulo operator is represented by the % symbol. It is a binary operator that takes two operands. Moreover, when it is applied it performs a division and returns the remainder.

1 2 3 4 5 | ```
@Test
public void modulo() {
final int result = 13 % 4;
assertEquals(1, result);
}
``` |

Note the result of applying the modulo operator returns the integer value 1. We could also obtain a decimal value by using a float or a double.

1 2 3 4 5 | ```
@Test
public void modulo_decimal() {
final float result = 13 % 4;
assertEquals(1.0, result, 0);
}
``` |

When we apply the modulo operator to floating point numbers it is important to be aware that there can be issues related to Floating Point Precision.

Moreover, just like you can’t divide by zero, the right hand operator of the modulo operator cannot be zero. If this is the case it will result in an ArithmeticException.

1 2 3 4 | ```
@Test(expected = ArithmeticException.class)
public void modulo_divideByZero() {
final int result = 13 % 0;
}
``` |

We can test if a number is even using the Modulo operator. This is because any number divided by 2 has a remainder of 0.

1 2 3 4 5 6 7 8 9 | ```
@Test
public void isEven() {
assertEquals(0, 4 % 2);
}
@Test
public void isOdd() {
assertNotEquals(0, 5 % 2);
}
``` |

This can be a handy mechanism. For example, if we have a loop and we want to perform a task every nth time.

1 2 3 4 5 | ```
for (int i = 0; i < 100; i++) {
if (i % 3 == 0) {
//do something every three iterations
}
}
``` |

We can also use the modulo operator to convert a number of seconds that have elapsed, into hours, minutes and seconds.

1 2 3 4 5 6 7 8 9 10 11 12 | ```
@Test
public void secondsAsUnits() {
final int elapsedSeconds = 643;
final int hours = elapsedSeconds / 3600;
final int minutes = (elapsedSeconds / 60) % 60;
final int seconds = elapsedSeconds % 60;
final String expected = "0:10:43";
final String actual = hours + ":" + minutes + ":" + seconds;
assertEquals(expected, actual);
}
``` |

The modulo operator can also be used, to maintain a bounded index. For example calculating the next index to write to in an array, without exceeding the arrays bounds.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | ```
@Test
public void boundedIndex_contrivedAddition() {
final int expectedSum = 15;
int[] calculatorMemory = new int[]{0,0};
int arrWriteIndex = 0;
for(int index=0; index<5; index++) {
arrWriteIndex = index % calculatorMemory.length;
int arrReadIndex = Math.abs(arrWriteIndex -1);
final int value = calculatorMemory[arrReadIndex] + (index + 1);
calculatorMemory[arrWriteIndex] = value;
}
assertEquals(expectedSum,calculatorMemory[arrWriteIndex]);
}
``` |

In the above example we sum all the integers from 1 to 5. The modulo operator is used to keep the array index for the array `calculatorMemory`

in bounds.

In this short tutorial we looked at the modulo operator in Java. We looked at how to use it and some of its common use cases.