Est-il une différence entre x++ et ++x en java?

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

Une fois le code exécuté, a et b seront 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);

Imprime 6 et

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

Imprimera 5.

J'ai atterri ici depuis l'un de ses récents dup, et bien que cette question soit plus que résolue, 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é en:

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

{Si vous[5]} ce 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 m'ai permis de commenter la méthode principale à l'aide de la machine virtuelle Java Spécifications):

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

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

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

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

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

Considérer: 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 passé le paramètre après récupération, après utilisation ou après le stockage.

Généralement, utilisez simplement x = x + 1. C'est 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 des variables puis utilise la nouvelle valeur dans l'expression.

Par exemple si 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 postfix: 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 si 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. De courir et de jouer avec le code ci-dessus devrait aider votre compréhension.

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'après l'évaluation de l'expression.

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 parce que 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 un tableau de Stack, qui est un peu plus rapide que celle de la liste liée.

Code ci-dessous, vérifiez les fonctions 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, encas de x++(post-incrémentation), la valeur de x sera utilisé dans l'expression et x sera incrémentée de 1 après l'expression a été évaluée, sur l'autre main ++x(pré-incrémentation), 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 est déjà résolue, mais permettez-moi d'ajouter de mon côté aussi.

Tout d'Abord ++ des moyens d'incrémentation par l'un et -- moyens de décrémentation par un.

Maintenant x++ moyens d'Incrémentation x après cette ligne et ++x moyens d'Incrémentation x avant de 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++, il s'appelle postincrement, et la valeur est utilisée dans n'importe quel contexte puis incrémentée; ++i est préincrement incrémente la valeur en premier, puis l'utilise en contexte.

Si vous ne l'utilisez dans aucun contexte, peu importe ce que vous utilisez, mais postincrement est utilisé par convention.

Il y a une énorme différence.

, Comme la plupart des réponses ont déjà souligné la théorie, je tiens à souligner un exemple facile:

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