Como os operadores de incremento de postagem (i ++) e de pré-incremento (++ i) funcionam em Java?

Você pode me explicar a saída deste 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); 

A saída é 20 em ambos os casos

Isso ajuda?

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

O ponto principal é que ++a incrementa o valor e o retorna imediatamente.

a++ também incrementa o valor (em segundo plano), mas retorna o valor inalterado da variável – o que parece ser executado mais tarde.

++a incrementa e depois usa a variável.
a++ usa e, em seguida, incrementa a variável.

Se você tem

 a = 1; 

e você faz

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

@codaddict explica seu snippet específico.

Em ambos os casos, ele calcula primeiro o valor, mas no pós-incremento ele mantém o valor antigo e, após o cálculo, o retorna.

++ a

  1. a = a + 1;
  2. return a;

um ++

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

é

 i = 6 + 7 + 7 

Trabalhando : incremento a 6 (valor atual 6) + incremento a a 7 (valor atual 7). A sum é 13 agora, adicione-o ao valor atual de a (= 7) e, em seguida, aumente para 8. A sum é 20 e o valor de a após a conclusão da atribuição é 8.

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

é

 i = 5 + 7 + 8 

Trabalhando : No valor inicial de a é 5. Use-o na adição e, em seguida, incremente-o para 6 (valor atual 6). Incrementar um valor atual de 6 a 7 para obter outro operando de +. A sum é 12 e o valor atual de a é 7. Em seguida, aumente de 7 para 8 (valor atual = 8) e adicione à sum anterior 12 para obter 20.

++a incrementa a antes de ser avaliado. a++ avalia a e, em seguida, incrementa-o.

Relacionado à sua expressão 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 

Os parenteses que usei acima são implicitamente usados ​​pelo Java. Se você observar os termos dessa maneira, poderá ver facilmente que eles são os mesmos que são comutativos.

No exemplo acima

 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 

++ é um operador de incremento de prefixo:

  • o resultado é calculado e armazenado primeiro,
  • então a variável é usada.

um ++ é um operador de incremento de postfix:

  • a variável é usada primeiro,
  • então o resultado é calculado e armazenado.

Depois de lembrar as regras, EZ para você calcular tudo!

quando a é 5, então a++ dá um 5 à expressão e incrementa a depois, enquanto ++a incrementa a antes de passar o número para a expressão (o que dá a 6 para a expressão neste caso).

Então você calcula

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

No entanto, se você combinar todas as suas declarações e executá-las no Java 8.1, receberá uma resposta diferente, pelo menos é o que minha experiência diz.

O código funcionará assim:

 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 

Presumindo que você quis dizer

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

Isso avalia para:

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

então eu é 6 + 7 + 7 = 20 e então 20 é impresso.

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

então eu tenho 5 + 7 + 8 = 20 e então 20 é impresso novamente.

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

e depois de todo o lado direito ser avaliado (incluindo a configuração de 8), então, a é definido como 6 + 7 + 7 = 20 e, assim, 20 é impresso pela última vez.

pré-incremento e pós incremento são equivalentes se não em uma expressão

 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++; 

é

 i = 7 + 6 + 7 

Trabalhando: pré / pós incremento tem “direita para esquerda” Associatividade, e pre tem precedência sobre post, então primeiro de tudo o pré incremento será resolvido como (++a + ++a) => 7 + 6 . então a=7 é fornecido para registrar incremento => 7 + 6 + 7 =20 e a =8 .

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

é

 i=7 + 7 + 6 

Trabalhando: pré / pós incremento tem “direita para esquerda” Associatividade, e pre tem precedência sobre post, então primeiro de tudo pré incremento será resolvido como (++a + ++a) => 7 + 6 Então a=7 é fornecido para postar incremento => 7 + 7 + 6 =20 e a =8 .

Eu acredito que você está executando todas essas declarações de forma diferente
executando 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)