Como os operadores pós-incremento (i ++) e 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 ++aincrementa o valor e o retorna imediatamente.

a++ também incrementa o valor (no fundo), mas retorna o valor inalterado da variável - o que parece ser executado mais tarde.

++aincrementos e então usa a variável.
a++usa e então 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 trecho específico.

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

++ a

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

a ++

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

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

é

i = 6 + 7 + 7

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

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

é

i = 5 + 7 + 8

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

++aincrementos aantes de ser avaliado. a++avalia ae então o incrementa.

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 parênteses que usei acima são usados ​​implicitamente por Java. Se você olhar para os termos desta forma, você pode facilmente ver que eles são iguais e 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

++ a é operador de incremento de prefixo:

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

a ++ é um operador de incremento postfix:

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

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

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:

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

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

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

então i é 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 que todo o lado direito é avaliado (incluindo a definição de a para 8) ENTÃO a é definido para 6 + 7 + 7 = 20 e assim 20 é impresso uma última vez.

quando aé 5, então a++dá 5 à expressão e incrementa adepois, enquanto ++aincrementa aantes de passar o número para a expressão (o que dá a6 para a expressão neste caso).

Então você calcula

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

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

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

Pré-incremento significa que a variável é incrementada ANTES de ser avaliada na expressão. Pós-incremento significa que a variável é incrementada DEPOIS de ter sido avaliada para uso na expressão.

Portanto, observe cuidadosamente e verá que todas as três atribuições são aritmeticamente equivalentes.

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

Funcionando: o pré / pós incremento tem associatividade da "direita para a esquerda", e o pré tem precedência sobre o pós, então antes de mais nada o pré-incremento será resolvido como (++a + ++a) => 7 + 6. então a=7é fornecido para postar incremento => 7 + 6 + 7 =20e a =8.

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

é

i=7 + 7 + 6

Trabalhando: pré / pós incremento tem "direita para a esquerda" Associatividade e pre tem precedência sobre post, então em primeiro lugar pré incremento será resolver como (++a + ++a) => 7 + 6.then a=7é fornecido para incremento post => 7 + 7 + 6 =20e a =8.

Eu acredito que você está executando todas essas instruções de forma diferente,
executando em conjunto resultará em => 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 <br>
i=a++ + ++a + ++a;
//this means i= 5+7+8=20 (this could be complicated, 
//but its working like this),<br>
a=++a + ++a + a++;
//as a is 6+7+7=20 (this is incremented like this)