Java: préfixe / postfix des opérateurs d'incrément/décrément?

je sais qu'on a répondu à cette question, mais j'ai pensé qu'une autre explication pourrait être utile.

une Autre façon d'illustrer qu'il est:

++i donne le résultat de new i,i++ donnera le résultat de l'original i et stocker l' new i pour la prochaine action.

une façon d'y penser, c'est de faire autre chose dans l'expression. Lorsque vous imprimez la valeur actuelle de i, il dépendra de si i a été changé dans l'expression ou après l'expression.

    int i = 1;
result i = ++i * 2 // result = 4, i = 2

i est évalué (changé) avant que le résultat ne soit calculé. Impression i pour cette expression, affiche la valeur changée de i utilisé pour cette expression.

result i = i++ * 2 // result = 2, i = 2

i est évaluée après le résultat calculé. Afin d'impression i de cette expression donne la valeur originale de i utilisé dans cette expression, mais i est toujours modifié pour d'autres utilisations. Si l'impression de la valeur de i immédiatement après l'expression, indique la nouvelle valeur incrémentée de i. Comme la valeur de i a changé, qu'il soit imprimé ou utilisé.

result i = i++ * 2 // result = 2, i = 2
System.out.println(i); // 2

si vous avez gardé 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++ type i = i+1. bien que ce ne soit pas la même chose. La différence, c'est quand en fait i sera attribué avec la nouvelle augmentation.

++i , l'accroissement se produit immédiatement.

mais si i++ y a-t-il un incrément qui se produira lorsque 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++;
}

il en résultera une boucle sans fin. parce que je serai retourné avec la valeur originale et après le point-virgule je vais être incrémenté mais la valeur retournée n'a pas été. Par conséquent, je ne retournerai jamais réellement comme une valeur incrémentée.

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

• Postfix: passe la valeur courante de i à la fonction puis l'incrémente.
• préfixe: incrémente la valeur courante et la passe ensuite à la fonction.

Les lignes où tu ne fais rien avec moi ne font aucune différence.

Notez que ceci est également vrai pour les missions:

i = 0;
test = ++i;  // 1
test2 = i++; // 1

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

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

Il imprime 7 pour le dernier énoncé, cos dans l'énoncé ci-dessus, sa valeur est 6 et c'est incrémenté à 7 lors de la dernière instruction est imprimé

Bien penser 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

Maintenant,

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"

peut-être Pouvez-vous mieux comprendre le 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);
    }
}    

C'est ma réponse. Certains d'entre vous peuvent trouver 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. 
    }
}