Why is Java not telling me when I can't use Integer?

For a small project (Problem 10 Project Euler) i tried to sum up all prime numbers below 2 millions. So I used a brute force method and iterated from 0 to 2'000'000 and checked if the number is a prime. If it is I added it to the sum:

private int sum = 0;

private void calculate() {
   for (int i = 0; i < 2000000; i++) {
      if (i.isPrime()) {
         sum = sum + i;
      }
   }
   sysout(sum)
}

The result of this calculation is 1179908154, but this is incorrect. So i changed int to BigInteger and now i get the correct sum 142913828922. Obviously the range of int was overflo开发者_如何学JAVAwed. But why can't Java tell me that? (e.g. by an exception)

Because it's conceivable that you might want it to behave in the traditional Integer fashion. Exceptions are reserved for things that are definitely and irrevocably wrong.

ETA: From the language spec:

"The built-in integer operators do not indicate overflow or underflow in any way. The only numeric operators that can throw an exception (§11) are the integer divide operator / (§15.17.2) and the integer remainder operator % (§15.17.3), which throw an ArithmeticException if the right-hand operand is zero."

(http://java.sun.com/docs/books/jls/second_edition/html/typesValues.doc.html)

Besides what Jim says, checking for conditions such as overflow would add a performance penalty to any calculation done with integers, which would make programs that do a lot of calculations a lot slower.

The other reason is that you can do this check yourself very easily and quickly.

if (sum+i < sum) {
  throw new AritchmeticException();
}

should do the trick nicely, given that you know i is always positive and less than Integer.MAX_VALUE.

Being aware of Integer.MAX_VALUE is always useful :)

Because our profession values performance over correctness. ;(

Using BigInteger by default, and only reasoning whether it is acceptable, to use long or int if performance is a real problem, would help to avoid such problems.