¿Cómo funcionan los operadores de incrementos posteriores (i ++) y preincrementados (++ i) en Java?

¿Me puede explicar el resultado de este código Java?

int a=5,i; i=++a + ++a + a++; i=a++ + ++a + ++a; a=++a + ++a + a++; System.out.println(a); System.out.println(i); 

La salida es 20 en ambos casos

    ¿Esto ayuda?

     a = 5; i=++a + ++a + a++; => i=6 + 7 + 7; (a=8) a = 5; i=a++ + ++a + ++a; => i=5 + 7 + 8; (a=8) 

    El punto principal es que ++a incrementa el valor y lo devuelve inmediatamente.

    a++ también incrementa el valor (en el fondo) pero devuelve el valor sin modificar de la variable, lo que parece que se ejecuta más tarde.

    ++a incrementa y luego usa la variable.
    a++ usa y luego incrementa la variable.

    Si usted tiene

     a = 1; 

    y lo hace

     System.out.println(a++); //You will see 1 //Now a is 2 System.out.println(++a); //You will see 3 

    @codaddict explica tu fragmento particular.

    En ambos casos, primero calcula el valor, pero en el incremento posterior retiene el valor anterior y luego de calcularlo lo devuelve

    ++ a

    1. a = a + 1;
    2. devolver a;

    a ++

    1. temp = a;
    2. a = a + 1;
    3. temperatura de retorno;
     i = ++a + ++a + a++; 

    es

     i = 6 + 7 + 7 

    Trabajo : incremente a a 6 (valor actual 6) + incremente a a 7 (valor actual 7). Suma es 13 ahora agréguela al valor actual de a (= 7) y luego incremente a a 8. La sum es 20 y el valor de a una vez que la tarea se completa es 8.

     i = a++ + ++a + ++a; 

    es

     i = 5 + 7 + 8 

    Trabajo : en el valor inicial de a es 5. Úselo en la sum y luego increméntelo a 6 (valor actual 6). Incremente a desde el valor actual de 6 a 7 para obtener otro operando de +. La sum es 12 y el valor actual de a es 7. A continuación, incremente de 7 a 8 (valor actual = 8) y agréguelo a la sum anterior 12 para obtener 20.

    ++a incrementa a antes de ser evaluado. a++ evalúa a y luego lo incrementa.

    Relacionado con tu expresión dada:

     i = ((++a) + (++a) + (a++)) == ((6) + (7) + (7)); // a is 8 at the end i = ((a++) + (++a) + (++a)) == ((5) + (7) + (8)); // a is 8 at the end 

    Las parentesas que utilicé anteriormente son utilizadas implícitamente por Java. Si miras los términos de esta manera, puedes ver fácilmente, que ambos son iguales ya que son conmutativos.

    En el ejemplo anterior

     int a = 5,i; i=++a + ++a + a++; //Ans: i = 6 + 7 + 7 = 20 then a = 8 i=a++ + ++a + ++a; //Ans: i = 8 + 10 + 11 = 29 then a = 11 a=++a + ++a + a++; //Ans: a = 12 + 13 + 13 = 38 System.out.println(a); //Ans: a = 38 System.out.println(i); //Ans: i = 29 

    ++ a es el operador de incremento de prefijo:

    • el resultado se calcula y almacena primero,
    • entonces la variable se usa.

    a ++ es el operador de incremento de postfix:

    • la variable se usa primero,
    • entonces el resultado se calcula y almacena.

    Una vez que recuerde las reglas, EZ para que pueda calcular todo!

    cuando a es 5, entonces a++ da 5 a la expresión e incrementa a después, mientras que ++a incrementa a antes de pasar el número a la expresión (que da a 6 a la expresión en este caso).

    Entonces usted calcula

     i = 6 + 7 + 7 i = 5 + 7 + 8 

    Sin embargo, creo que si combina todas sus declaraciones y las ejecuta en Java 8.1 obtendrá una respuesta diferente, al menos eso es lo que dice mi experiencia.

    El código funcionará así:

     int a=5,i; i=++a + ++a + a++; /*a = 5; i=++a + ++a + a++; => i=6 + 7 + 7; (a=8); i=20;*/ i=a++ + ++a + ++a; /*a = 5; i=a++ + ++a + ++a; => i=8 + 10 + 11; (a=11); i=29;*/ a=++a + ++a + a++; /*a=5; a=++a + ++a + a++; => a=12 + 13 + 13; a=38;*/ System.out.println(a); //output: 38 System.out.println(i); //output: 29 

    Suponiendo que quisiste decir

     int a=5; int i; i=++a + ++a + a++; System.out.println(i); a=5; i=a++ + ++a + ++a; System.out.println(i); a=5; a=++a + ++a + a++; System.out.println(a); 

    Esto evalúa a:

     i = (6, a is now 6) + (7, a is now 7) + (7, a is now 8) 

    entonces yo soy 6 + 7 + 7 = 20 y entonces 20 está impreso.

     i = (5, a is now 6) + (7, a is now 8) + (8, a is now 9) 

    entonces yo soy 5 + 7 + 8 = 20 y entonces 20 se imprime nuevamente.

     a = (6, a is now 6) + (7, a is now 7) + (7, a is now 8) 

    y después de que se evalúa todo el lado derecho (incluida la configuración de a 8) ENTONCES a se establece en 6 + 7 + 7 = 20 y 20 se imprime por última vez.

    el incremento previo y el incremento posterior son equivalentes si no están en una expresión

     int j =0; int r=0 for(int v = 0; v<10; ++v) { ++r; j++; System.out.println(j+" "+r); } 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 
     a=5; i=++a + ++a + a++; 

    es

     i = 7 + 6 + 7 

    Trabajo: el incremento pre / post tiene asociatividad de “derecha a izquierda”, y pre tiene prioridad sobre la publicación, por lo que antes de nada se resolverá como (++a + ++a) => 7 + 6 . entonces a=7 se proporciona para el incremento posterior => 7 + 6 + 7 =20 y a =8 .

     a=5; i=a++ + ++a + ++a; 

    es

     i=7 + 7 + 6 

    Trabajo: el incremento pre / post tiene asociatividad “de derecha a izquierda”, y pre tiene prioridad sobre la publicación, por lo que antes de nada se resolverá como (++a + ++a) => 7 + 6 .entonces a=7 se proporciona para incrementos posteriores => 7 + 7 + 6 =20 y a =8 .

    Creo que estás ejecutando todas estas declaraciones de manera diferente
    ejecutando juntos resultará => 38, 29

     int a=5,i; i=++a + ++a + a++; //this means i= 6+7+7=20 and when this result is stored in i, //then last *a* will be incremented 
    i=a++ + ++a + ++a; //this means i= 5+7+8=20 (this could be complicated, //but its working like this),
    a=++a + ++a + a++; //as a is 6+7+7=20 (this is incremented like this)