Comment les post-incrémentation (i ++) et pré-incrémentation (++ i) fonctionnent-ils en Java?

est-ce que cela aide?

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

Le point principal est que ++a incrémente la valeur et la retourne immédiatement.

a++ incrémente également la valeur (en arrière-plan) mais renvoie la valeur inchangée de la variable – ce qui semble être exécuté ultérieurement.

++a incrémente puis utilise la variable.
a++ utilise et incrémente la variable.

Si tu as

 a = 1; 

et vous faites

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

@codaddict explique votre extrait de code particulier.

Dans les deux cas, il calcule d’abord la valeur, mais en post-incrémentation, il contient l’ancienne valeur et, après le calcul, la retourne

++ a

1. a = a + 1;
2. retourner un;

a ++

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

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

est

 i = 6 + 7 + 7 

Working : incrémente a à 6 (valeur actuelle 6) + incrémente a à 7 (valeur actuelle 7). La sum est 13, ajoutez-la maintenant à la valeur actuelle de (= 7), puis augmentez-la de 8. La sum est égale à 20 et la valeur de a après la fin de l’affectation est 8.

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

est

 i = 5 + 7 + 8 

Working : à la valeur de départ de a est 5. Utilisez-le dans l’addition et ensuite l’incrémenter à 6 (valeur actuelle 6). Incrémente de la valeur actuelle 6 à 7 pour obtenir un autre opérande de +. La sum est 12 et la valeur actuelle de a est 7. Ensuite, incrémentez de 7 à 8 (valeur actuelle = 8) et ajoutez-la à la sum précédente 12 pour obtenir 20.

++a s’incrémente avant son évaluation. a++ évalue a puis l’incrémente.

Relatif à votre expression donnée:

 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 

Les parentés que j’ai utilisées ci-dessus sont implicitement utilisées par Java. Si vous regardez les termes de cette manière, vous pouvez facilement voir qu’ils sont tous les deux identiques en tant que commutatifs.

Dans l’exemple ci-dessus

 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 est l’opérateur d’incrémentation de préfixe:

• le résultat est calculé et stocké en premier,
• alors la variable est utilisée.

a ++ est un opérateur d’incrémentation postfixé:

• la variable est utilisée en premier,
• le résultat est alors calculé et stocké.

Une fois que vous vous souvenez des règles, EZ pour vous de tout calculer!

quand a est 5, alors a++ donne un 5 à l’expression et l’incrémente après, tandis que ++a incrémente a avant de passer le nombre à l’expression (ce qui donne a 6 à l’expression dans ce cas).

Donc, vous calculez

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

Je crois cependant que si vous combinez toutes vos déclarations et que vous l’exécutez en Java 8.1, vous obtiendrez une réponse différente, du moins c’est ce que mon expérience dit.

Le code fonctionnera comme ceci:

 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 

En supposant que vous vouliez dire

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

Cela évalue à:

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

donc i est 6 + 7 + 7 = 20 et donc 20 est imprimé.

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

donc i est 5 + 7 + 8 = 20 et donc 20 est imprimé à nouveau.

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

et après tout le côté droit est évalué (y compris le réglage de a à 8) ALORS a est réglé à 6 + 7 + 7 = 20 et ainsi 20 est imprimé une dernière fois.

pré-incrémentation et post-incrémentation sont équivalents sinon dans une expression

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

est

 i = 7 + 6 + 7 

Fonctionnement: l’incrémentation pré / post a une associativité “de droite à gauche”, et le pré a la priorité sur post, donc tout d’abord l’incrémentation préalable sera résolue comme (++a + ++a) => 7 + 6 . alors a=7 est fourni pour enregistrer l’incrément => 7 + 6 + 7 =20 et a =8 .

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

est

 i=7 + 7 + 6 

Fonctionnement: l’incrémentation pré / post a une associativité “de droite à gauche” et pre a la priorité sur post, donc tout d’abord l’incrémentation préalable sera résolue comme (++a + ++a) => 7 + 6 .then a=7 est fourni pour afficher incrément => 7 + 7 + 6 =20 et a =8 .

Je crois que vous exécutez toutes ces déclarations différemment
exécuter ensemble entraînera => 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)