年年有余

        int a = 5%3; //

        int b = 5/3; //

        System.out.println("5%3 produces " + a +" (note that 5/3 produces " + b + ")");

　　　　　　　　　　5%3 produces 2 (note that 5/3 produces 1)

        int c = 5%(-3); //

        int d = 5/(-3); // -1

        System.out.println("5%(-3) produces " + c +" (note that 5/(-3) produces " + d + ")");

        int e = (-5)%3; // -2

        int f = (-5)/3; // -1

        System.out.println("(-5)%3 produces " + e +" (note that (-5)/3 produces " + f + ")");

        int g = (-5)%(-3); // -2

        int h = (-5)/(-3); //

        System.out.println("(-5)%(-3) produces " + g +" (note that (-5)/(-3) produces " + h + ")");

　　　　　　　　　　5%(-3) produces 2 (note that 5/(-3) produces -1)

　　　　　　　　　　(-5)%3 produces -2 (note that (-5)/3 produces -1)

　　　　　　　　　　(-5)%(-3) produces -2 (note that (-5)/(-3) produces 1)

The binary % operator is said to yield the remainder of its operands from an implied division; the left-hand operand is the dividend and the right-hand operand is the divisor.

It follows from this rule that the result of the remainder operation can be negative only if the dividend is negative, and can be positive only if the dividend is positive. Moreover, the magnitude of the result is always less than the magnitude of the divisor.

class Test2 {

 public static void main(String[] args) {

 double a = 5.0%3.0; // 2.0

 System.out.println("5.0%3.0 produces " + a);

 double b = 5.0%(-3.0); // 2.0

 System.out.println("5.0%(-3.0) produces " + b);

 double c = (-5.0)%3.0; // -2.0

 System.out.println("(-5.0)%3.0 produces " + c);

 double d = (-5.0)%(-3.0); // -2.0

 System.out.println("(-5.0)%(-3.0) produces " + d);

 }

}

5.0%3.0 produces 2.0

5.0%(-3.0) produces 2.0

(-5.0)%3.0 produces -2.0

(-5.0)%(-3.0) produces -2.0

The result of a floating-point remainder operation as computed by the % operator is not the same as that produced by the remainder operation defined by IEEE 754. The IEEE 754 remainder operation computes the remainder from a rounding division, not a truncating division, and so its behavior is not analogous to that of the usual integer remainder operator. Instead, the Java programming language defines % on floating-point operations to behave in a manner analogous to that of 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.

The result of a floating-point remainder operation is determined by the rules of IEEE 754 arithmetic:

If either operand is NaN, the result is NaN.

If the result is not NaN, the sign of the result equals the sign of the dividend.

If the dividend is an infinity, or the divisor is a zero, or both, the result is NaN.

If the dividend is finite and the divisor is an infinity, the result equals the dividend.

If the dividend is a zero and the divisor is finite, the result equals the dividend.

In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, the floating-point remainder r from the division of a dividend n by a divisor d is defined by the mathematical relation r = n - (d ⋅ q) where q is an integer that is negative only if n/d is negative and positive only if n/d is positive, and whose magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient of n and d.

Evaluation of a floating-point remainder operator % never throws a run-time exception, even if the right-hand operand is zero. Overflow, underflow, or loss of precision cannot occur.

    public static void main(String[] args) {

        final int MODULUS = 3;

        int[] histogram = new int[MODULUS];

        // Iterate over all ints (Idiom from Puzzle 26)

        int i = Integer.MIN_VALUE;

        do {

        histogram[Math.abs(i) % MODULUS]++;

        } while (i++ != Integer.MAX_VALUE);

        for (int j = 0; j < MODULUS; j++)

        System.out.println(histogram[j] + " ");

    }

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -2

    at com.java.puzzlers.ModTest.main(ModTest.java:11)

 /**

 * Returns the absolute value of an {@code int} value.

 * If the argument is not negative, the argument is returned.

 * If the argument is negative, the negation of the argument is returned.

 *

 * <p>Note that if the argument is equal to the value of

 * {@link Integer#MIN_VALUE}, the most negative representable

 * {@code int} value, the result is that same value, which is

 * negative.

 *

 * @param a the argument whose absolute value is to be determined

 * @return the absolute value of the argument.

 */

 public static int abs(int a) {

 return (a < 0) ? -a : a;

 }