# For what value of i does while (i == i + 1) {} loop forever?

• A+
Category：Languages

Consider the following loop, in which i is, so far, undeclared:

``while (i == i + 1) {} ``

Find the definition of `i`, that precedes this loop, such that the while loop continues for ever.

The next question, which asked the same question for this code snippet:

``while (i != i) {} ``

was obvious to me. Of course in this other situation it is `NaN` but I am really stuck on the prior one. Does this have to do with overflow? What would cause such a loop to loop for ever in Java?

First of all, since the `while (i == i + 1) {}` loop doesn't change the value of `i`, making this loop infinite is equivalent to choosing a value of `i` that satisfies `i == i + 1`.

There are many such values:

``double i = Double.POSITIVE_INFINITY; ``

or

``double i =  Double.NEGATIVE_INFINITY; ``

The reason for these values satisfying `i == i + 1` is stated in
JLS 15.18.2. Additive Operators (+ and -) for Numeric Types:

The sum of an infinity and a finite value is equal to the infinite operand.

This is not surprising, since adding a finite value to an infinite value should result in an infinite value.

That said, most of the values of `i` that satisfy `i == i + 1` are simply large `double` (or `float`) values:

For example:

``double i = Double.MAX_VALUE; ``

or

``double i = 1000000000000000000.0; ``

or

``float i = 1000000000000000000.0f; ``

The `double` and `float` types have limited precision, so if you take a large enough `double` or `float` value, adding `1` to it will result in the same value.