How to Check if Multiplying Two Numbers in Java Will Cause an Overflow

1. Overview

In Java, multiplying two numbers can lead to overflow if the result exceeds the limits of the data type (int or long). Java 8 introduced Math.multiplyExact(), automatically detecting overflow and throwing an ArithmeticException. However, before Java 8, manual methods were required to check for overflow.

This article discusses the modern approach using Math.multiplyExact() and a primitive method to detect overflow when multiplying two numbers.

2. Using Math.multiplyExact() for Overflow Detection

Java 8 introduced the Math.multiplyExact() method, which checks for overflow during multiplication. If overflow occurs, it throws an ArithmeticException. This method supports both int and long types.

Here’s how we can check for overflow using Math.multiplyExact() for both int and long values:

public class OverflowCheck {
    public static boolean checkMultiplication(int a, int b) {
        try {
            Math.multiplyExact(a, b);
            return true; // No overflow
        } catch (ArithmeticException e) {
            return false; // Overflow occurred
        }
    }
    public static boolean checkMultiplication(long a, long b) {
        try {
            Math.multiplyExact(a, b);
            return true; // No overflow
        } catch (ArithmeticException e) {
            return false; // Overflow occurred
        }
    }
}

In the above example, we created two methods: checkMultiplication(int a, int b) and checkMultiplication(long a, long b). The first method checks for overflow when multiplying two integers, and the second checks for overflow with long values.

Both methods catch the ArithmeticException and return a boolean, where true indicates successful multiplication (no overflow), and false otherwise.

Let’s examine a unit test that includes various multiplication scenarios for both int and long, addressing cases with and without overflow:

@Test
public void givenVariousInputs_whenCheckingForOverflow_thenOverflowIsDetectedCorrectly() {
    // Int tests
    assertTrue(OverflowCheck.checkMultiplication(2, 3)); // No overflow
    assertFalse(OverflowCheck.checkMultiplication(Integer.MAX_VALUE, 3_000)); // Overflow
    assertTrue(OverflowCheck.checkMultiplication(100, -200)); // No overflow (positive * negative)
    assertFalse(OverflowCheck.checkMultiplication(Integer.MIN_VALUE, -2)); // Overflow (negative * negative)
    assertTrue(OverflowCheck.checkMultiplication(-100, -200)); // No overflow (small negative values)
    assertTrue(OverflowCheck.checkMultiplication(0, 1000)); // No overflow (multiplying with zero)
    // Long tests
    assertTrue(OverflowCheck.checkMultiplication(1_000_000_000L, 10_000_000L)); // No overflow
    assertFalse(OverflowCheck.checkMultiplication(Long.MAX_VALUE, 2L)); // Overflow
    assertTrue(OverflowCheck.checkMultiplication(1_000_000_000L, -10_000L)); // No overflow (positive * negative)
    assertFalse(OverflowCheck.checkMultiplication(Long.MIN_VALUE, -2L)); // Overflow (negative * negative)
    assertTrue(OverflowCheck.checkMultiplication(-1_000_000L, -10_000L)); // No overflow (small negative values)
    assertTrue(OverflowCheck.checkMultiplication(0L, 1000L)); // No overflow (multiplying with zero)
}

In the above unit test, we first verify that multiplying small positive integers (2 * 3) and large values (1 billion * 10 million) stay within the int and long bounds, respectively, without causing overflow.

Multiplying Integer.MAX_VALUE by 3.000 and Long.MAX_VALUE by 2 correctly triggers overflow, as both exceed their type limits.

Mixed-sign multiplications, such as 100 * -200 and 1 billion * -10,000, do not cause overflow. For negative values, multiplying Integer.MIN_VALUE by -2 and Long.MIN_VALUE by -2 results in overflow, while smaller negative values like -100 * -200 and -1,000,000 * -10,000 do not.

Finally, multiplying any value by 0 always avoids overflow.

These cases collectively validate that the checkMultiplication() method accurately detects safe and overflow-prone multiplications for both int and long types.

3. Primitive Method for Overflow Detection

Before Java 8, we needed to manually detect overflow during multiplication because there was no built-in method like Math.multiplyExact(). The general idea is to verify whether multiplying two numbers would exceed the bounds of the data type by rearranging the multiplication logic. We do this by comparing the operands against the data type’s maximum and minimum possible values.

Here’s how we can check for overflow using primitive methods for both int and long values:

public class PrimitiveOverflowCheck {
    public static boolean willOverflow(int a, int b) {
        if (a == 0 || b == 0) return false;
        if (a > 0 && b > 0 && a > Integer.MAX_VALUE / b) return true;
        if (a > 0 && b < 0 && b < Integer.MIN_VALUE / a) return true;
        if (a < 0 && b > 0 && a < Integer.MIN_VALUE / b) return true;
        return a < 0 && b < 0 && a < Integer.MAX_VALUE / b;
    }
    public static boolean willOverflow(long a, long b) {
        if (a == 0 || b == 0) return false;
        if (a > 0 && b > 0 && a > Long.MAX_VALUE / b) return true;
        if (a > 0 && b < 0 && b < Long.MIN_VALUE / a) return true;
        if (a < 0 && b > 0 && a < Long.MIN_VALUE / b) return true;
        return a < 0 && b < 0 && a < Long.MAX_VALUE / b;
    }
}

The willOverflow(int a, int b) method checks if multiplying two int values will exceed the maximum or minimum values of the int type. It considers cases where the operands are positive or negative and whether their product would exceed the range.

Similarly, for long values, the willOverflow(long a, long b) method performs a check to ensure that their multiplication doesn’t surpass the bounds of the long type.

A key component of this method is the final check, which specifically addresses the situation where both values are negative. This check is crucial because, without it, we might overlook cases where the multiplication of two negative numbers produces a positive result that exceeds the allowed maximum for the data type. This can occur because, in the case of integer overflow, two large negative numbers can produce a positive result that lies outside the permissible range of int values.

Both methods use a similar approach to detect overflow by comparing the operands against their respective types’ maximum and minimum values, ensuring that multiplication results remain within the safe range.

Here is a simple unit test that covers many possible cases of overflow:

@Test
public void givenVariousInputs_whenCheckingForOverflow_thenOverflowIsDetectedCorrectly() {
    // Int tests
    assertFalse(PrimitiveOverflowCheck.willOverflow(2, 3)); // No overflow
    assertTrue(PrimitiveOverflowCheck.willOverflow(Integer.MAX_VALUE, 3_000)); // Overflow
    assertFalse(PrimitiveOverflowCheck.willOverflow(100, -200)); // No overflow (positive * negative)
    assertTrue(PrimitiveOverflowCheck.willOverflow(Integer.MIN_VALUE, -2)); // Overflow (negative * negative)
    assertFalse(PrimitiveOverflowCheck.willOverflow(-100, -200)); // No overflow (small negative values)
    assertFalse(PrimitiveOverflowCheck.willOverflow(0, 1000)); // No overflow (multiplying with zero)
    // Long tests
    assertFalse(PrimitiveOverflowCheck.willOverflow(1_000_000_000L, 10_000_000L)); // No overflow
    assertTrue(PrimitiveOverflowCheck.willOverflow(Long.MAX_VALUE, 2L)); // Overflow
    assertFalse(PrimitiveOverflowCheck.willOverflow(1_000_000_000L, -10_000L)); // No overflow (positive * negative)
    assertTrue(PrimitiveOverflowCheck.willOverflow(Long.MIN_VALUE, -2L)); // Overflow (negative * negative)
    assertFalse(PrimitiveOverflowCheck.willOverflow(-1_000_000L, -10_000L)); // No overflow (small negative values)
    assertFalse(PrimitiveOverflowCheck.willOverflow(0L, 1000L)); // No overflow (multiplying with zero)
}

This test is similar to the one from earlier, confirming that willOverflow() correctly identifies overflow conditions for both int and long types. It ensures that the method accurately detects when multiplication operations will overflow, aligning with the behavior of Math.multiplyExact().

4. Conclusion

Detecting overflow during multiplication is crucial for avoiding unexpected results. Java 8’s Math.multiplyExact() provides a simple, built-in way to check for overflow by throwing an ArithmeticException. However, in earlier versions of Java or for specific use cases, manual (primitive) methods can also be used to detect overflow. Both approaches can safely handle arithmetic operations without producing invalid results.

As always, the source code is available over on GitHub.