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

Y a-t-il une différence entre ++ x et x ++ dans Java?

++ x s’appelle preincrement tandis que x ++ s’appelle postincrement.

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 s’incrémente

Exemple:

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

une fois le code exécuté, a et b seront 1 mais x sera 2.

Celles-ci sont appelées opérateurs postfix et prefix. Les deux appendont 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 6 et

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

imprimera 5 .

J’ai atterri ici d ‘un de ses derniers dup ‘ s, et bien que cette question soit plus que répondue, je ne pouvais pas m’empêcher de décomstackr le code et d ‘append “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 Y.java cette classe Y.java :

 public class Y { public static void main(Ssortingng []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 Java Virtual Machine ):

 public class Y extends java.lang.Object{ public Y(); Code: 0: aload_0 1: invokespecial #1; //Method java/lang/Object."":()V 4: return public static void main(java.lang.Ssortingng[]); 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 

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 ++: charge x depuis la mémoire, utilise, incrémente, stocke en mémoire.

Considérez: 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 stockage.

En général, utilisez simplement x = x + 1. C’est beaucoup plus simple.

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

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

++ x est un 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 un formulaire de postfixe: 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. Courir et jouer avec le code ci-dessus devrait aider votre compréhension.

Oui, en utilisant ++ X, X + 1 sera utilisé dans l’expression. En utilisant X ++, X sera utilisé dans l’expression et X sera seulement augmenté 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 pouvez 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(Ssortingng 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 classique de la stack. Juste un rappel que cela est utilisé dans l’implémentation basée sur le tableau 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 FixedCapacityStackOfSsortingngs { private Ssortingng[] s; private int N=0; public FixedCapacityStackOfSsortingngs(int capacity) { s = new Ssortingng[capacity];} public boolean isEmpty() { return N == 0;} public void push(Ssortingng item) { s[N++] = item; } public Ssortingng pop() { Ssortingng item = s[--N]; s[N] = null; return item; } } 

Oui, il y a une différence, en cas de x ++ (postincrement), la valeur de x sera utilisée dans l’expression et x sera incrémenté de 1 après l’évaluation de l’expression, d’autre part ++ x (preincrement), x + 1 sera utilisé dans l’expression. Prenons un exemple:

 public static void main(Ssortingng 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’append aussi de mon côté.

Tout d’abord ++ signifie une augmentation de 1 et signifie une diminution de 1.

Maintenant, x ++ signifie Increment x après cette ligne et ++ x signifie Increment x avant cette ligne.

Vérifiez cet exemple

 class Example { public static void main (Ssortingng 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é; ++ i is preincrement incrémente d’abord la valeur et l’utilise ensuite en contexte.

Si vous ne l’utilisez pas dans n’importe quel contexte, peu importe ce que vous utilisez, mais le postincrement est utilisé par convention.

Il ya une énorme différence.

Comme la plupart des réponses ont déjà mis en évidence la théorie, je voudrais souligner 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);