Operador de incremento de publicación que no se incrementa en bucle for

Estoy investigando sobre Java y encuentro esto muy confuso:

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

¡Esto nunca termina con el ciclo!

¿Alguien tiene una buena explicación de por qué sucede eso?

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

El ciclo anterior es esencialmente el mismo que:

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

la parte de su enunciado for - i = i++ , se evalúa como: -

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

Debes eliminar la tarea desde allí para que funcione:

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

(En la solicitud OP de Comentarios)

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

En cuanto a su problema como se especifica en el comentario, el resultado de la siguiente expresión:

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

se obtiene de la siguiente manera:

Marquemos diferentes partes de la segunda afirmación:

 x = x++ + x++; RAB 

Ahora, primero se evaluará la parte RHS (A + B) y luego se asignará el resultado final a x . Entonces, avancemos.

Primero A se evalúa:

 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. 

Ahora, dado que la asignación de A a R no se realiza aquí, el 3er paso no se realiza.

Ahora, pase a la evaluación 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. 

Ahora, para obtener el valor de x++ + x++ , tenemos que hacer la última tarea que dejamos en la evaluación de A y B , porque ahora es el valor asignado en x . Para eso, tenemos que reemplazar:

 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. **/ 

Entonces, x = x++ + x++ , se convierte en: -

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

Desglose de la tercera parte de x = x++ , para ver cómo funciona en x = x++ + x++ caso: -

A --> old1 pregunto por qué el reemplazo se hace como A --> old1 y no x --> old1 , como en el caso de x = x++ .

Eche un vistazo profundo a la parte x = x++ , especialmente la última tarea:

 x = oldValue; 

si considera que x++ es A aquí, la tarea anterior se puede dividir en estos pasos:

 A = oldValue; x = A; 

Ahora, para el problema actual, es lo mismo que:

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

Espero que eso lo aclare.

Está usando un incremento posterior: i = i++; , significa algo como esto:

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

porque 15.14.2 Operador de Incremento de Postfix ++ :

El valor de la expresión de incremento postfix es el valor de la variable antes de que se almacene el nuevo valor.

Es por eso que tienes el valor anterior.

For-loop hecho a la derecha:

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

por i = i ++

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

i ++ informará el valor de i, y luego boostá. Esto también significa que no necesita establecer i igual a i ++, solo cambie a

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

El problema está en la statement i=i++ , esta instrucción realiza tres operaciones en secuencia para completar. Estas son dos operaciones en i++ y una operación de asignación ( = ). Estos son;

i++ realiza dos operaciones antes de cualquier operación

  1. Devuelve i

  2. Incrementos i

finalmente operación de asignación

  1. Asigna valor devuelto

Por lo tanto, se incrementa antes de la asignación para que tenga un valor anterior.

Veamos i=i++ en el primer ciclo (donde i = 0 ) con las tres operaciones

  1. devuelve 0 , no se asignará a i hasta que se i la siguiente operación
  2. incrementos i ( i= 0 + 1 = 1 )
  3. asigna el valor devuelto 0 i , ( i = 0 ), finalmente i tiene su valor anterior.

En i++ primero se devuelve i , pero inmediatamente antes de que se realice cualquier operación, se incrementa ( i convierte en i+1 ). Sin embargo, todavía nos queda la operación de asignación para completar, de modo que el valor devuelto se asignará a i haciendo que tenga valor, ingresando de esta forma bucle infinito.

entonces reemplace i=i++ con i++ o i=i+1