java - una - operadores incrementales y decrementales

Java: ¿Prefijo/postfijo de operadores de incremento/decremento?

Question

Desde el programa a continuación o here , ¿por qué la última llamada a System.out.println(i) imprime el valor 7 ?

class PrePostDemo {
public static void main(String[] args){
int i = 3;
i++;
System.out.println(i); // "4"
++i;
System.out.println(i); // "5"
System.out.println(++i); // "6"
System.out.println(i++); // "6"
System.out.println(i); // "7"
}
}

Answer 1

¿Por qué la variable no se habría actualizado?

• Postfix: pasa el valor actual de i a la función y luego lo incrementa.
• Prefijo: incrementa el valor actual y luego lo pasa a la función.

Las líneas en las que no haces nada no hacen ninguna diferencia.

Tenga en cuenta que esto también es cierto para las asignaciones:

i = 0;
test = ++i; // 1
test2 = i++; // 1

Answer 2

Bueno, piense en términos de variables temporales.

i =3 ;
i ++ ; // is equivalent to: temp = i++; and so , temp = 3 and then "i" will increment and become i = 4;
System.out.println(i); // will print 4

Ahora,

i=3;
System.out.println(i++);

es equivalente a

temp = i++; // temp will assume value of current "i", after which "i" will increment and become i= 4
System.out.println(temp); //we''re printing temp and not "i"

Answer 3

Esta es mi respuesta. Algunos de ustedes pueden encontrarlo fácil de entender.

package package02;
public class C11PostfixAndPrefix {
public static void main(String[] args) {
// In this program, we will use the value of x for understanding prefix
// and the value of y for understaning postfix.
// Let''s see how it works.
int x = 5;
int y = 5;
Line 13: System.out.println(++x); // 6 This is prefixing. 1 is added before x is used.
Line 14: System.out.println(y++); // 5 This is postfixing. y is used first and 1 is added.
System.out.println("---------- just for differentiating");
System.out.println(x); // 6 In prefixing, the value is same as before {See line 13}
System.out.println(y); // 6 In postfixing, the value increases by 1 {See line 14}
// Conclusion: In prefixing (++x), the value of x gets increased first and the used
// in an operation. While, in postfixing (y++), the value is used first and changed by
// adding the number.
}
}

Answer 4

Imprime 7 para la última declaración, cos en la declaración anterior, su valor es 6 y se incrementa a 7 cuando se imprime la última declaración

Answer 5

Piense en ++i y i++ como SIMILAR a i = i+1. Aunque no es MISMO. La diferencia es cuando en realidad se i asignará el nuevo incremento.

en ++i , el incremento ocurre inmediatamente.

pero si i++ está allí, el incremento ocurrirá cuando el programa pase a la siguiente línea.

Mira el código aquí.

int i = 0;
while(i < 10){
System.out.println(i);
i = increment(i);
}
private int increment(i){
return i++;
}

Esto dará como resultado un bucle sin finalización . porque seré devuelto con el valor original y después del punto y coma me aumentará pero el valor devuelto no ha sido. Por lo tanto, nunca volveré como un valor incrementado.

Answer 6

Quizás puedas entender mejor Prefijo / postfijo con este ejemplo.

public class TestPrefixPostFix
{
public static void main (String[] args)
{
int x=10;
System.out.println( (x++ % 2 == 0)?"yes "+ x: " no "+x);
x=10;
System.out.println( (++x % 2 == 0)?"yes "+ x: " no "+x);
}
}

Answer 7

Sé que esto ha sido respondido, pero pensé que otra explicación podría ser útil.

Otra forma de ilustrarlo es:

++i el resultado del new i , i++ dará el resultado del i original y almacenará el new i para la siguiente acción.

Una manera de pensarlo es haciendo algo más dentro de la expresión. Cuando está imprimiendo el valor actual de i , dependerá de si i sido cambiado dentro de la expresión o después de la expresión.

 int i = 1;
result i = ++i * 2 // result = 4, i = 2

i es evaluado (cambiado) antes de que se calcule el resultado. Al imprimir i para esta expresión, se muestra el valor modificado de i utilizado para esta expresión.

result i = i++ * 2 // result = 2, i = 2

i se evalúa después del resultado en calculado. Entonces, imprimir i desde esta expresión da el valor original de i usado en esta expresión, pero todavía se cambia para cualquier uso posterior. Entonces, al imprimir el valor de i inmediatamente después de la expresión, se mostrará el nuevo valor incrementado de i . Como el valor de i ha cambiado, ya sea impreso o usado.

result i = i++ * 2 // result = 2, i = 2
System.out.println(i); // 2

Si mantuvo un patrón consistente e incluyó líneas de impresión para todos los valores:

 int i = 3;
System.out.println(i); // 3
System.out.println(i++); // 3
System.out.println(i); // "4"
System.out.println(++i); // 5
System.out.println(i); // "5"
System.out.println(++i); // "6"
System.out.println(i++); // "6"
System.out.println(i); // "7"

Answer 8

System.out.println(i++); // "6"

Esto envía println el valor que tenía antes de esta línea de código (6), y luego incrementa I (a 7).

Answer 9

i = 5;
System.out.println(++i); //6

Esto imprime "6" porque toma i agrega uno y devuelve el valor. 5 + 1 = 6; Esto es prefijando, agregando al número antes de usarlo en la operación.

i = 6;
System.out.println(i++); //6 (i = 7, prints 6)

Esto imprime "6" porque toma i, almacena una copia, agrega 1 y devuelve la copia. Así que obtienes el valor que yo tenía, pero también lo incrementas al mismo tiempo. Por lo tanto, imprime el valor anterior, pero se incrementa. La belleza de un incremento de postfix.

Luego, cuando imprime i, muestra el valor real de i porque se ha incrementado. 7