How many times will the x variable be created at the end of the loop? Why?

Question

In the following loop, how many times the variable x will be created at the end of loop? Why?

for (int i = 0; < 10; i++) 
{
    double x = i + 10;
    System.out.println(x);
}

Answer 1

The word "created" there is a little complicated. Informally we use the word, but creation is not quite the term that occurs there in this code. There is a variable declaration x, and only once, so you wonder how many times it happens one. If you want to know how many variables are created there, it’s just one. If you want to know how many spaces in memory are allocated to this variable, it’s just one space. For all purposes there is only creation of a variable.

If by variable we understand what it really is, namely a storage place with a name for easy access, so there is only the creation of one variable.

There are 10 assignments in this only variable and therefore are created 10 values (object instances) that are successively stored in the same variable, so despite the positive votes and acceptance, the other answers are wrong and confused with the idea of variable and value (one of them even answers the question).

When you declare a local variable to a method a space in the pile. A space is reserved for each variable and the space depends on the size of the object, and the objects by reference have the size of a pointer. In your case, there’s only one statement and one space. It is guaranteed that each of the 10 passed in this variable statement only needs one space and has no reason to reserve more than one space for it.

The same way if you have different levels of scope only need to reserve space for the largest amount of variables that exist at the same time (considering their sizes). So if a variable is used in a block with defined scope and then another variable is created in another distinct, non-nested block, although having two statements of variables only takes one space for one of the variables, even if they are different. The compiler always creates the space as optimally as possible. The variable statement is not a code execution mechanism, it is a space structuring command in memory and only needs to do this once in the loop. It’s the same as doing this, but keeping scope:

double x;
for (int i = 0; i< 10; i++) {
    x = i + 10;
    System.out.println(x);
}

I don’t know if you have any way to show Java-generated Assembly online, but in C++ you have how and I will show how it makes no difference (Java is no different than C++):

main:
    push    rbx
    mov     ebx, 10
.L2:
    pxor    xmm0, xmm0
    mov     edi, OFFSET FLAT:_ZSt4cout
    cvtsi2sd        xmm0, ebx
    add     ebx, 1
    call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)
    cmp     ebx, 20
    jne     .L2
    xor     eax, eax
    pop     rbx
    ret

Behold in the Compiler Explorer.

main:
    push    rbx
    mov     ebx, 10
.L2:
    pxor    xmm0, xmm0
    mov     edi, OFFSET FLAT:_ZSt4cout
    cvtsi2sd        xmm0, ebx
    add     ebx, 1
    call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)
    cmp     ebx, 20
    jne     .L2
    xor     eax, eax
    pop     rbx
    ret

Behold in the Compiler Explorer.

Note that gives the same generated code.

Answer 2

10 times, i starts at 0 and goes up to smaller (<) than 10 ie 9 times

i= 0
i= 1
i= 2
i= 3
i= 4
i= 5
i= 6
i= 7
i= 8
i= 9