Y a-t-il une différence entre x++ et ++x en java ?

Question

Y a-t-il une différence entre ++x et x++ en java ?

Answer 1

++x est appelé préincrément et x++ est appelé postincrément.

int x = 5, y = 5;

System.out.println(++x); // outputs 6
System.out.println(x); // outputs 6

System.out.println(y++); // outputs 5
System.out.println(y); // outputs 6

Answer 2

Sí

++x incrémente la valeur de x et renvoie x
x++ renvoie la valeur de x et l'incrémente ensuite

exemple :

x=0;
a=++x;
b=x++;

après l'exécution du code, a et b seront à 1 mais x sera à 2.

Answer 3

Il s'agit des opérateurs postfixe et préfixe. Les deux ajouteront 1 à la variable, mais le résultat de l'instruction est différent.

int x = 0;
int y = 0;
y = ++x;            // result: y=1, x=1

int x = 0;
int y = 0;
y = x++;            // result: y=0, x=1

Answer 4

Oui,

int x=5;
System.out.println(++x);

imprimera 6 et

int x=5;
System.out.println(x++);

imprimera 5 .

Answer 5

J'ai atterri ici à la suite d'une de ses récentes dup et bien que cette question soit plus que répondue, je n'ai pas pu m'empêcher de décompiler le code et d'ajouter "encore une autre réponse" :-)

Pour être précis (et probablement un peu pédant),

int y = 2;
y = y++;

est compilé dans :

int y = 2;
int tmp = y;
y = y+1;
y = tmp;

Si vous javac cette Y.java classe :

public class Y {
    public static void main(String []args) {
        int y = 2;
        y = y++;
    }
}

et javap -c Y vous obtenez le code jvm suivant (je me suis permis de commenter la méthode principale à l'aide de la balise Spécification de la machine virtuelle Java ) :

public class Y extends java.lang.Object{
public Y();
  Code:
   0:   aload_0
   1:   invokespecial  #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   iconst_2 // Push int constant `2` onto the operand stack. 

   1:   istore_1 // Pop the value on top of the operand stack (`2`) and set the
                 // value of the local variable at index `1` (`y`) to this value.

   2:   iload_1  // Push the value (`2`) of the local variable at index `1` (`y`)
                 // onto the operand stack

   3:   iinc  1, 1 // Sign-extend the constant value `1` to an int, and increment
                   // by this amount the local variable at index `1` (`y`)

   6:   istore_1 // Pop the value on top of the operand stack (`2`) and set the
                 // value of the local variable at index `1` (`y`) to this value.
   7:   return

}

C'est ainsi que nous avons enfin :

0,1: y=2
2: tmp=y
3: y=y+1
6: y=tmp