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

113

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

erickreutz
la source
53
Cue un torrent de réponses identiques ...
skaffman
5
... et vote favorable de la première des réponses identiques pour entrer ...
skaffman
9
au plus vite aller le butin, trier par plus ancien, cliquez sur vote. ohowoho.
dotjoe
1
J'étais sûr de l'avoir! La réponse d'Emil est meilleure de toute façon.
Victor

Réponses:

290

++ 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
Emil H
la source
62
Bonne explication, 1 ++. Oups, ++ 1 :)
nawfal
67

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.

Victor
la source
10
+1 Beaucoup d'exemples, ceci est une explication avec des exemples :)
Jeremy Smyth
1
Ouais, j'ai aussi fini par voter celui-ci à cause de l'explication claire en prose au début. (Hmm, je ne savais pas que vous pouvez faire de la cursive dans les commentaires de nos jours ... cool )
Jonik
17

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
Pablojim
la source
Ne devrait-il pas l'être suffix?
HyperNeutrino
10

Oui,

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

imprimera 6et

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

imprimera 5.

Johannes Weiss
la source
1
@Tom, je réfléchissais juste à la manière de voter, alors voici mon interprétation: une petite raison de préférer la réponse d'Emil H est que son exemple de code est / légèrement / plus informatif.
Jonik
Jonik. Vrai, inclut également les mots-clés «préincrémentation» et «postincrémentation».
Tom
Cette "réponse" vous indique simplement une sortie de cas de test, et je considère que les sorties ne sont pas des réponses. Au contraire, normalement le résultat (inattendu) d'une exécution de code conduit à la question. D'où mon vote négatif.
Alberto de Paola
8

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
Alberto
la source
7

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.

Cornell
la source
5

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.

Jeremy Levett
la source
3

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);
    }
}
Carl Manaster
la source
2

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.

nojevive
la source
2

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

flq
la source
2

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
Lars Haugseth
la source
1

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;
  }
}
kasaquan
la source
1

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);  
}
Rohit Goyal
la source
1

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
Saif
la source
1
Cette réponse serait encore meilleure si elle était accompagnée de quelques mots d'explication.
Thom
0

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.

takra
la source
0

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);
Pritam Banerjee
la source