Java: Prefixo / postfix de operadores de incremento / decremento?

No programa abaixo ou aqui , por que a última chamada para System.out.println(i) imprime o 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" } } 

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

Isso imprime “6” porque é necessário adicionar um a ele e retorna o valor. 5 + 1 = 6; Isso é prefixado, adicionando ao número antes de usá-lo na operação.

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

Isso imprime “6”, porque leva i, armazena uma cópia, adiciona 1 e retorna a cópia. Então você obtém o valor que eu estava, mas também o incrementa ao mesmo tempo. Portanto, você imprime o valor antigo, mas ele é incrementado. O beautfy de um incremento de postfix.

Então, quando você imprime i, mostra o valor real de i porque ele foi incrementado. 7

Eu sei que isso foi respondido, mas pensei que outra explicação pode ser útil.

Outra maneira de ilustrar isso é:

++i darei o resultado do new i , i++ dará o resultado do i original e armazenará o new i para a próxima ação.

Uma maneira de pensar nisso é fazer outra coisa dentro da expressão. Quando você está imprimindo o valor atual de i , isso dependerá se i tiver sido alterado dentro da expressão ou após a expressão.

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

i é avaliado (alterado) antes de o resultado ser calculado. Imprimindo i para esta expressão, mostra o valor alterado de i usado para esta expressão.

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

i é avaliado após o resultado em calculado. Portanto, imprimir i desta expressão fornece o valor original de i usado nesta expressão, mas ainda é alterado para quaisquer outros usos. Portanto, imprimir o valor para i imediatamente após a expressão mostrará o novo valor incrementado de i . Como o valor de i mudou, seja impresso ou usado.

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

Se você mantivesse um padrão consistente e incluísse linhas de impressão para todos os 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" 

Pense em ++i e i++ como SIMILAR em i = i+1. Embora não seja o mesmo. Diferença é quando na verdade i serei designado com o novo incremento.

Em ++i , incremento acontece imediatamente.

mas se i++ existir, o incremento acontecerá quando o programa for para a próxima linha.

Veja o código aqui.

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

Isso resultará em um loop sem finalização . porque eu vou ser devolvido com o valor original e depois do ponto-e-vírgula i será incrementado, mas o valor retornado não foi. Portanto, eu nunca retornarei como um valor incrementado.

Por que a variável não foi atualizada?

  • Postfix: passa o valor atual de i para a function e, em seguida, incrementa-o.
  • Prefixo: incrementa o valor atual e passa para a function.

As linhas onde você não faz nada não fazem diferença.

Observe que isso também é verdade para atribuições:

 i = 0; test = ++i; // 1 test2 = i++; // 1 
 System.out.println(i++); // "6" 

Isso envia println o valor que eu tinha antes desta linha de código (6) e, em seguida, incrementa I (para 7).

Ele imprime 7 para a última declaração, porque na declaração acima, seu valor é 6 e é incrementado para 7 quando a última declaração é impressa.

Bem pense nisso em termos de variables ​​temporárias.

 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 

Agora,

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

é 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" 

Talvez você possa entender melhor o prefixo / postfix com este exemplo.

 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); } } 

Esta é minha resposta. Alguns de vocês podem achar isso 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. } }