Dans le programme ci-dessous ou ici , pourquoi le dernier appel à System.out.println(i)
affiche-t-il la valeur 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
Ceci affiche "6" car il faut y ajouter un et retourner la valeur. 5 + 1 = 6; C'est préfixer, ajouter au nombre avant de l'utiliser dans l'opération.
i = 6;
System.out.println(i++); //6 (i = 7, prints 6)
Ceci affiche "6" car il faut i, stocke une copie, ajoute 1 et renvoie la copie. Donc, vous obtenez la valeur que j'étais, mais vous l'incrémentez également en même temps. Par conséquent, vous imprimez l'ancienne valeur, mais celle-ci est incrémentée. La beauté d'un incrément postfixé.
Ensuite, lorsque vous imprimez i, il indique la valeur réelle de i car elle a été incrémentée. 7
Je sais que cela a été répondu, mais je pense qu'une autre explication peut être utile.
Une autre façon de l'illustrer est:
++i
donnera le résultat du new i
, i++
donnera le résultat de la i
originale et stockera le new i
pour l'action suivante.
Une façon de penser est de faire quelque chose d'autre dans l'expression. Lorsque vous imprimez la valeur actuelle de i
, cela dépend si i
a été modifié dans l'expression ou après l'expression.
int i = 1;
result i = ++i * 2 // result = 4, i = 2
i
est évalué (modifié) avant que le résultat ne soit calculé. L'impression i
pour cette expression affiche la valeur modifiée de i
utilisée pour cette expression.
result i = i++ * 2 // result = 2, i = 2
i
est évalué après le résultat calculé. Donc, imprimer i
à partir de cette expression donne la valeur originale de i
utilisée dans cette expression, mais i
reste modifié pour toute utilisation ultérieure. Ainsi, l’impression de la valeur i
immédiatement après l’expression affichera la nouvelle valeur incrémentée de i
. Comme la valeur de i
a changé, qu'elle soit imprimée ou utilisée.
result i = i++ * 2 // result = 2, i = 2
System.out.println(i); // 2
Si vous avez conservé un motif cohérent et inclus des lignes d'impression pour toutes les valeurs:
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"
Pensez à ++i
et i++
comme SIMILAIRE à i = i+1.
mais ce n’est pas la même chose. La différence est lorsque i
obtient le nouvel incrément.
dans ++i
, l'incrément se produit immédiatement.
mais si i++
est là, l'incrément se produira quand le programme passera à la ligne suivante.
Regardez le code ici.
int i = 0;
while(i < 10){
System.out.println(i);
i = increment(i);
}
private int increment(i){
return i++;
}
Ceci entraînera une boucle sans fin . parce que i
sera retourné avec la valeur originale et après le point-virgule, je serai incrémenté mais la valeur renvoyée ne sera pas. Par conséquent, i
ne sera jamais renvoyé sous forme de valeur incrémentée.
System.out.println(i++); // "6"
Ceci envoie println
la valeur que j'avais avant cette ligne de code (6), puis incrémente I (à 7).
Pourquoi la variable n'aurait-elle pas été mise à jour?
Les lignes où vous ne faites rien avec je ne fais aucune différence.
Notez que cela est également vrai pour les affectations:
i = 0;
test = ++i; // 1
test2 = i++; // 1
Il imprime 7 pour la dernière déclaration, car dans la déclaration ci-dessus, sa valeur est 6 et il est incrémenté à 7 lorsque la dernière déclaration est imprimée.
Pensez-y en termes de variables temporaires.
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
À présent,
i=3;
System.out.println(i++);
est équivalent à
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"
Ceci est ma réponse. Certains d’entre vous trouveront peut-être cela facile à comprendre.
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.
}
}
Peut-être que vous pouvez mieux comprendre Préfixe/Postfix avec cet exemple.
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);
}
}