In Java you take the remainder with the % operator.
% is informally called the modulus
operator, (sometimes called mod or modulo) though mathematicians and serious computer scientists would beg
to differ, it is a remainder operator not a modulus. The JLS (Java Language Specification) correctly refers to
it as a remainder operator.
Happily, Java division has the Euclidean property namely
when you multiply the quotient by the divisor and add the remainder you get back to
the dividend. When you ask for % 3 in Java, you may be
astounded to sometimes get an answer outside the range 0..2. See remainder/modulus sign rules. Be especially careful when
corralling random numbers into a smaller range with the % operator.
Negative Operands
Java’s modulus behaves, well,
strangely. In Java, the sign of the remainder follows the dividend, not the divisor
as you would expect. % can produce a negative result
even with a positive divisor. Be especially careful when corralling random numbers
into a smaller range with the modulus operator, e.g. wheel.nextInt() % 3 will give you numbers 2 ..
+2 not 0 .. 2 as most would expect.
For example, when you do a day of week calculation by taking day_number % 7
in Java, you will be astounded to sometimes get a
negative answer outside the range 0 .. 6, namely when the
dividend is negative. See sign rules. Java
division is truncated division.
Mixed Base Calculations
The modulus operator is useful in time
calculation, e. g. how many days, hours, minutes, seconds, milliseconds is
112,233,445,566,778,899 milliseconds?
Going the other way from days, hours, minutes and seconds to milliseconds is easier.
You just multiply each component static final long MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000L;
static final long MILLISECONDS_PER_HOUR = 60 * 60 * 1000L;
static final long MILLISECONDS_PER_MINUTE = 60 * 1000L;
static final long MILLISECONDS_PER_SECOND = 1000L;
long millis = days * MILLISECONDS_PER_DAY + hours * MILLISECONDS_PER_HOUR
+ minutes * MILLISECONDS_PER_MINUTE
+ seconds * MILLISECONDS_PER_SECOND
+ milliseconds;
This is a rather simplistic answer to the problem. For more complicated answers see
Calendar.
You can use similar logic to deal with other goofy mixed base systems like
latitude and longitude with its degrees, minutes and seconds, yards, feet and inches
or tons, pounds and ounces. APL (A Programming Language) has builtin operators to neatly handle these. In Java
you have to code the conversions out longhand.
Sign Rules
Remainder, modulus and division are often defined
in a quirky way in computer languages, often to make it quick and easy to implement
on the author’s hardware. Java has %, the
remainder operator, but does not have a builtin modulus operator or function.
Signs 
Division / 
Remainder % 
Modulus 
+ + 
7 / 4 = 1 
7 % 4 = 3 
7 mod 4 = 3 
 + 
7 / 4 = 1 
7 % 4 = 3 
7 mod 4 = 1 
+  
7 / 4 = 1 
7 % 4 = 3 
7 mod 4 = 1 
  
7 / 4 = +1 
7 % 4 = 3 
7 mod 4 = 3 
Honing Your Intuition
By examining the patterns in the
following three tables of Java remainder %,
mod mathematical modulus and / integer division, you will have a better intuition of how they
work. Note how for Java %, the sign of the divisor is irrelevant. The sign of the
result follows the sign of the dividend. Note for mathematical modulus, the result is
always in the range 0..divisor1 for positive divisors, irrespective of the sign of
the dividend, and the result is always in the range divisor+1..0 for negative
divisors, irrespective of the sign of the dividend. % and modulus give the same
results when the signs of dividend and divisor match. It is interesting to note how
complex the symmetries and repetitions are.
division
division

Integer Division: col / row 

10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
10 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
10 
9 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
9 
8 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
8 
7 
1 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
1 
7 
6 
1 
1 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
1 
1 
6 
5 
2 
1 
1 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
1 
1 
2 
5 
4 
2 
2 
2 
1 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
1 
2 
2 
2 
4 
3 
3 
3 
2 
2 
2 
1 
1 
1 
0 
0 
0 
0 
0 
1 
1 
1 
2 
2 
2 
3 
3 
3 
2 
5 
4 
4 
3 
3 
2 
2 
1 
1 
0 
0 
0 
1 
1 
2 
2 
3 
3 
4 
4 
5 
2 
1 
10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
1 
0 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0 
1 
10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
1 
2 
5 
4 
4 
3 
3 
2 
2 
1 
1 
0 
0 
0 
1 
1 
2 
2 
3 
3 
4 
4 
5 
2 
3 
3 
3 
2 
2 
2 
1 
1 
1 
0 
0 
0 
0 
0 
1 
1 
1 
2 
2 
2 
3 
3 
3 
4 
2 
2 
2 
1 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
1 
2 
2 
2 
4 
5 
2 
1 
1 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
1 
1 
2 
5 
6 
1 
1 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
1 
1 
6 
7 
1 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
1 
7 
8 
1 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
1 
8 
9 
1 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
1 
9 
10 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
10 

10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 



Java Remainder: col % row == col  row * ( col / row
) 

10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
10 
0 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
0 
10 
9 
1 
0 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
0 
1 
9 
8 
2 
1 
0 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
0 
1 
2 
8 
7 
3 
2 
1 
0 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
0 
1 
2 
3 
7 
6 
4 
3 
2 
1 
0 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
0 
1 
2 
3 
4 
6 
5 
0 
4 
3 
2 
1 
0 
4 
3 
2 
1 
0 
1 
2 
3 
4 
0 
1 
2 
3 
4 
0 
5 
4 
2 
1 
0 
3 
2 
1 
0 
3 
2 
1 
0 
1 
2 
3 
0 
1 
2 
3 
0 
1 
2 
4 
3 
1 
0 
2 
1 
0 
2 
1 
0 
2 
1 
0 
1 
2 
0 
1 
2 
0 
1 
2 
0 
1 
3 
2 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
2 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
0 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
2 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
2 
3 
1 
0 
2 
1 
0 
2 
1 
0 
2 
1 
0 
1 
2 
0 
1 
2 
0 
1 
2 
0 
1 
3 
4 
2 
1 
0 
3 
2 
1 
0 
3 
2 
1 
0 
1 
2 
3 
0 
1 
2 
3 
0 
1 
2 
4 
5 
0 
4 
3 
2 
1 
0 
4 
3 
2 
1 
0 
1 
2 
3 
4 
0 
1 
2 
3 
4 
0 
5 
6 
4 
3 
2 
1 
0 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
0 
1 
2 
3 
4 
6 
7 
3 
2 
1 
0 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
0 
1 
2 
3 
7 
8 
2 
1 
0 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
0 
1 
2 
8 
9 
1 
0 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
0 
1 
9 
10 
0 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
0 
10 

10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 



Mathematical Modulus: col mod row == (col % row + row)
% row 

10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
10 
0 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
10 
9 
1 
0 
8 
7 
6 
5 
4 
3 
2 
1 
0 
8 
7 
6 
5 
4 
3 
2 
1 
0 
8 
9 
8 
2 
1 
0 
7 
6 
5 
4 
3 
2 
1 
0 
7 
6 
5 
4 
3 
2 
1 
0 
7 
6 
8 
7 
3 
2 
1 
0 
6 
5 
4 
3 
2 
1 
0 
6 
5 
4 
3 
2 
1 
0 
6 
5 
4 
7 
6 
4 
3 
2 
1 
0 
5 
4 
3 
2 
1 
0 
5 
4 
3 
2 
1 
0 
5 
4 
3 
2 
6 
5 
0 
4 
3 
2 
1 
0 
4 
3 
2 
1 
0 
4 
3 
2 
1 
0 
4 
3 
2 
1 
0 
5 
4 
2 
1 
0 
3 
2 
1 
0 
3 
2 
1 
0 
3 
2 
1 
0 
3 
2 
1 
0 
3 
2 
4 
3 
1 
0 
2 
1 
0 
2 
1 
0 
2 
1 
0 
2 
1 
0 
2 
1 
0 
2 
1 
0 
2 
3 
2 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
2 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
0 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0 
1 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
0 
1 
2 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
1 
0 
2 
3 
2 
0 
1 
2 
0 
1 
2 
0 
1 
2 
0 
1 
2 
0 
1 
2 
0 
1 
2 
0 
1 
3 
4 
2 
3 
0 
1 
2 
3 
0 
1 
2 
3 
0 
1 
2 
3 
0 
1 
2 
3 
0 
1 
2 
4 
5 
0 
1 
2 
3 
4 
0 
1 
2 
3 
4 
0 
1 
2 
3 
4 
0 
1 
2 
3 
4 
0 
5 
6 
2 
3 
4 
5 
0 
1 
2 
3 
4 
5 
0 
1 
2 
3 
4 
5 
0 
1 
2 
3 
4 
6 
7 
4 
5 
6 
0 
1 
2 
3 
4 
5 
6 
0 
1 
2 
3 
4 
5 
6 
0 
1 
2 
3 
7 
8 
6 
7 
0 
1 
2 
3 
4 
5 
6 
7 
0 
1 
2 
3 
4 
5 
6 
7 
0 
1 
2 
8 
9 
8 
0 
1 
2 
3 
4 
5 
6 
7 
8 
0 
1 
2 
3 
4 
5 
6 
7 
8 
0 
1 
9 
10 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
0 
10 

10 
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 


Getting the digits of a Number, any Radix
Modulus can be used to
take a number apart into digits, decimal, hexadecimal or any other base.
Even or Odd?
You can tell if an int is
even or odd by looking at its remainder, modulus 2:
boolean even = x % 2 == 0;
boolean odd = x % 2 != 0;
Note this similar code you often see posted will not work for
negative numbers: boolean even = x % 2 == 0;
boolean odd = x % 2 == 1;
There is a faster way to compute these, by masking off the low order bit:
boolean even = ( x & 1 ) == 0;
boolean odd = ( x & 1 ) != 0;
The code can be even faster if you want a number 0 or 1 as the result, say for
indexing an array, instead of a boolean:
int odd = x & 1;
Every nth
Let’s say you wanted to do something every fourth
line, e.g. insert a blank, a coloured bar, a tick…
Other Uses
Modulus can be used in computing the next free circular
squirrel cage buffer. int nextbuf = ( thisbuf + 1 ) % supply;
Modulus can be used to turn an offset into a file into a chunk number and offset
within that chunk. int recordNumber = fileOffset / blockSize;
int recordOffset = fileOffset % blockSize;
Floating Point %
% is also defined to work with
float and double operands,
though that use is quite rare.
The result of a floatingpoint remainder operation as computed by the % operator is not the same as that produced by the remainder
operation defined by the IEEE 754 floating
point standard. The IEEE (Institute of Electrical & Electronics Engineers) 754 remainder
operation computes the remainder from a rounding division, not a truncating division.
% on floatingpoint operations behaves analogously to
the integer remainder operator; this may be compared with the C library function
fmod. The IEEE
754 remainder operation may be computed by the library routine Math. IEEEremainder. (Note the violation of the naming
conventions.)
Learning More