Operador pós incremento não incrementando em loop

Estou fazendo uma pesquisa sobre Java e acho isso muito confuso:

for (int i = 0; i < 10; i = i++) { System.err.print("hoo... "); } 

Isso é interminável loop!

Alguém tem uma boa explicação porque tal coisa acontece?

 for (int i = 0; i < 10; i = i++) { 

O loop acima é essencialmente o mesmo que: -

 for (int i = 0; i < 10; i = i) { 

a terceira parte da sua declaração for - i = i++ , é avaliada como: -

 int oldValue = i; i = i + 1; i = oldValue; // 3rd Step 

Você precisa remover a atribuição de lá, para que funcione:

 for (int i = 0; i < 10; i++) { 

(Em pedido de OP de Comentários)

Comportamento de x = 1; x = x++ + x++; x = 1; x = x++ + x++; : -

No que diz respeito ao seu problema, conforme especificado no comentário, o resultado da seguinte expressão:

 x = 1; x = x++ + x++; 

é obtido da seguinte forma:

Vamos marcar partes diferentes da segunda afirmação:

 x = x++ + x++; RAB 

Agora, primeiro a parte RHS (A + B) será avaliada e, em seguida, o resultado final será atribuído a x . Então, vamos seguir em frente.

Primeiro A é avaliado: -

 old1 = x; // `old1 becomes 1` x = x + 1; // Increment `x`. `x becomes 2` //x = old1; // This will not be done. As the value has not been assigned back yet. 

Agora, como a atribuição de A a R não é feita aqui, a terceira etapa não é executada.

Agora, vá para a avaliação B :

 old2 = x; // old2 becomes 2. (Since `x` is 2, from the evaluation of `A`) x = x + 1; // increment `x`. `x becomes 3`. // x = old2; // This will again not be done here. 

Agora, para obter o valor de x++ + x++ , precisamos fazer a última atribuição que deixamos na avaliação de A e B , porque agora é o valor que está sendo atribuído em x . Para isso, precisamos replace:

 A --> old1 B --> old2 // The last assignment of both the evaluation. (A and B) /** See Break up `x = old1;` towards the end, to understand how it's equivalent to `A = old1; in case of `x = x++`, considering `x++ <==> A` in this case. **/ 

Então, x = x++ + x++ , torna-se: -

 x = old1 + old2; = 1 + 2; = 3; // Hence the answer 

Divisão da 3ª parte de x = x++ , para ver como funciona no caso x = x++ + x++ : -

Pergunto-me porque a substituição é feita como A --> old1 e não x --> old1 , como no caso de x = x++ .

Dê uma olhada na parte x = x++ , especialmente na última tarefa: -

 x = oldValue; 

se você considera x++ como A aqui, então a atribuição acima pode ser dividida nestas etapas:

 A = oldValue; x = A; 

Agora, para o problema atual, é o mesmo que: -

 A = old1; B = old2; x = A + B; 

Espero que isso fique claro.

Você está usando pós-incremento: i = i++; , significa algo assim:

 temp = i; i = i + 1; i = temp; 

porque 15.14.2 Operador de Incremento de Postfix ++ :

O valor da expressão de incremento do postfix é o valor da variável antes que o novo valor seja armazenado.

É por isso que você tem o valor antigo.

For-loop feito certo:

 for (int i = 0; i < 10; i++) { System.err.print("hoo... "); } 

por causa de i = i ++

 for (int i = 0; i < 10; i++) { System.err.print("hoo... "); } 

O i ++ irá reportar o valor de i, e THEN increment. Isso também significa que você não precisa definir i igual a i ++, apenas mude para

 for (int i = 0; i < 10; i++) { 

O problema está na declaração i=i++ , esta declaração faz três operações em sequência para completar. estas são duas operações em i++ e uma operação de atribuição ( = ). Esses são;

i++ faz duas operações antes de qualquer operação

  1. Retorna i

  2. Incrementos i

finalmente operação de atribuição

  1. Atribui valor retornado

Então, i é incrementado antes da atribuição, fazendo com que tenha valor antigo.

Vamos ver i=i++ no primeiro loop (onde i = 0 ) com as três operações

  1. retorna 0 , não será atribuído a i até que a próxima operação seja feita
  2. incrementos i ( i= 0 + 1 = 1 )
  3. atribui o valor retornado 0 a i , ( i = 0 ), finalmente tendo seu valor antigo.

Em i++ primeiro i é retornado, mas imediatamente antes que qualquer operação seja feita, é incrementada ( i torna-se i+1 ), no entanto ainda temos a operação de atribuição concluída, para que o valor retornado seja atribuído a valor, inserindo assim loop infinito.

então substitua i=i++ por i++ ou i=i+1