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

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

++ x est appelé pré-incrémentation tandis que x ++ est appelé post-incré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

Oui

++ x incrémente la valeur de x puis retourne x
x ++ renvoie la valeur de x puis incrémente

exemple:

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

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

Ceux-ci sont connus sous le nom d'opérateurs postfix et prefix. Les deux ajouteront 1 à la variable mais il y a une différence dans le résultat de l'instruction.

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

Oui,

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

imprimera 6et

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

imprimera 5.

J'ai atterri ici de l'un de ses récents dup , et bien que cette question ait plus que répondu, 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 javaccette Y.javaclasse:

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

}

Ainsi, nous avons enfin:

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

Quand on considère ce que fait réellement l'ordinateur ...

++ x: charger x depuis la mémoire, incrémenter, utiliser, réenregistrer en mémoire.

x ++: charger x à partir de la mémoire, utiliser, incrémenter, stocker en mémoire.

Considérons: a = 0 x = f (a ++) y = f (++ a)

où la fonction f (p) renvoie p + 1

x sera 1 (ou 2)

y sera 2 (ou 1)

Et c'est là que réside le problème. L'auteur du compilateur a-t-il transmis le paramètre après la récupération, après l'utilisation ou après le stockage.

Généralement, utilisez simplement x = x + 1. C'est beaucoup plus simple.

En Java, il y a une différence entre x ++ et ++ x

++ x est une forme de préfixe: il incrémente l'expression de variables puis utilise la nouvelle valeur dans l'expression.

Par exemple, s'il est utilisé dans le code:

int x = 3;

int y = ++x;
//Using ++x in the above is a two step operation.
//The first operation is to increment x, so x = 1 + 3 = 4
//The second operation is y = x so y = 4

System.out.println(y); //It will print out '4'
System.out.println(x); //It will print out '4'

x ++ est une forme de suffixe: la valeur des variables est d'abord utilisée dans l'expression, puis elle est incrémentée après l'opération.

Par exemple, s'il est utilisé dans le code:

int x = 3;

int y = x++;
//Using x++ in the above is a two step operation.
//The first operation is y = x so y = 3
//The second operation is to increment x, so x = 1 + 3 = 4

System.out.println(y); //It will print out '3'
System.out.println(x); //It will print out '4' 

J'espère que c'est clair. Exécuter et jouer avec le code ci-dessus devrait vous aider à comprendre.

Oui.

public class IncrementTest extends TestCase {

    public void testPreIncrement() throws Exception {
        int i = 0;
        int j = i++;
        assertEquals(0, j);
        assertEquals(1, i);
    }

    public void testPostIncrement() throws Exception {
        int i = 0;
        int j = ++i;
        assertEquals(1, j);
        assertEquals(1, i);
    }
}

Oui, en utilisant ++ X, X + 1 sera utilisé dans l'expression. En utilisant X ++, X sera utilisé dans l'expression et X ne sera augmenté qu'une fois l'expression évaluée.

Donc si X = 9, en utilisant ++ X, la valeur 10 sera utilisée, sinon, la valeur 9.

Si c'est comme beaucoup d'autres langues, vous voudrez peut-être essayer simplement:

i = 0;
if (0 == i++) // if true, increment happened after equality check
if (2 == ++i) // if true, increment happened before equality check

Si ce qui précède ne se produit pas comme ça, ils peuvent être équivalents

Oui, la valeur renvoyée est la valeur après et avant l'incrémentation, respectivement.

class Foo {
    public static void main(String args[]) {
        int x = 1;
        int a = x++;
        System.out.println("a is now " + a);
        x = 1;
        a = ++x;
        System.out.println("a is now " + a);
    }
}

$ java Foo
a is now 1
a is now 2

OK, j'ai atterri ici car j'ai récemment rencontré le même problème lors de la vérification de l'implémentation de la pile classique. Juste un rappel que cela est utilisé dans l'implémentation basée sur les tableaux de Stack, qui est un peu plus rapide que celle de la liste liée.

Code ci-dessous, vérifiez la fonction push et pop.

public class FixedCapacityStackOfStrings
{
  private String[] s;
  private int N=0;

  public FixedCapacityStackOfStrings(int capacity)
  { s = new String[capacity];}

  public boolean isEmpty()
  { return N == 0;}

  public void push(String item)
  { s[N++] = item; }

  public String pop()
  { 
    String item = s[--N];
    s[N] = null;
    return item;
  }
}

Oui, il y a une différence, en cas de x ++ (post-incrémentation), la valeur de x sera utilisée dans l'expression et x sera incrémenté de 1 après l'évaluation de l'expression, par contre ++ x (pré-incrément), x + 1 sera utilisé dans l'expression. Prenons un exemple:

public static void main(String args[])
{
    int i , j , k = 0;
    j = k++; // Value of j is 0
    i = ++j; // Value of i becomes 1
    k = i++; // Value of k is 1
    System.out.println(k);  
}

La question a déjà reçu une réponse, mais permettez-moi d'ajouter de mon côté aussi.

Tout d'abord ++ signifie incrémenter de un et - signifie décrémenter de un.

Maintenant, x ++ signifie Incrément x après cette ligne et ++ x signifie Incrément x avant cette ligne.

Vérifiez cet exemple

class Example {
public static void main (String args[]) {
      int x=17,a,b;
      a=x++;
      b=++x;
      System.out.println(“x=” + x +“a=” +a);
      System.out.println(“x=” + x + “b=” +b);
      a = x--;
      b = --x;
      System.out.println(“x=” + x + “a=” +a);
      System.out.println(“x=” + x + “b=” +b);
      }
}

Il donnera la sortie suivante:

x=19 a=17
x=19 b=19
x=18 a=19
x=17 b=17

Avec i ++, cela s'appelle postincrement, et la valeur est utilisée dans n'importe quel contexte puis incrémentée; ++ i is preincrement incrémente d'abord la valeur, puis l'utilise en contexte.

Si vous ne l'utilisez dans aucun contexte, peu importe ce que vous utilisez, mais le post-incrémentation est utilisé par convention.

Il ya une énorme différence.

Comme la plupart des réponses ont déjà souligné la théorie, je voudrais donner un exemple simple:

int x = 1;
//would print 1 as first statement will x = x and then x will increase
int x = x++;
System.out.println(x);

Voyons maintenant ++x:

int x = 1;
//would print 2 as first statement will increment x and then x will be stored
int x = ++x;
System.out.println(x);