web-dev-qa-db-fra.com

Java: préfixe/suffixe des opérateurs d'incrémentation/décrémentation?

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"
     }
}
javapost-incrementpre-increment
27
O_O
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

61
Spidy

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"
13
Yvette Colomb

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.

4
Dilruk
System.out.println(i++);  // "6"

Ceci envoie println la valeur que j'avais avant cette ligne de code (6), puis incrémente I (à 7).

2
Jumbogram

Pourquoi la variable n'aurait-elle pas été mise à jour?

  • Postfixe: passe la valeur actuelle de i à la fonction, puis l'incrémente.
  • Préfixe: incrémente la valeur actuelle puis la transmet à la fonction.

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
2
Steven Jeuris

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.

1
Guest

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"
0
Raj Shetty

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. 
    }
}
0
Babu Ram Acharya

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