Existe-t-il une différence entre x ++ et ++ x en java?
Existe-t-il une différence entre ++ x et x ++ en Java?
++ x est appelé préincrémentation tandis que x ++ est appelée postincrémentation.
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 renvoie 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 tous deux égaux à 1 mais x sera égal à 2.
Celles-ci sont appelées opérateurs postfixés et préfixés. Les deux vont ajouter 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 à partir de l'un de ses récents dup , et bien que cette question soit plus que réponse, je n'ai pas pu m'empêcher de décompiler le code et d'ajouter "encore une 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 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 m’ai autorisé à 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."<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
En considérant ce que l'ordinateur fait réellement ...
++ x: charge x de la mémoire, incrémente, utilise, enregistre à nouveau.
x ++: charge x de la mémoire, utilise, incrémente, enregistre à nouveau 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 la récupération, après l'utilisation ou après le stockage?.
Généralement, il suffit d'utiliser 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 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 postfixe: .__ La valeur de la variable est d'abord utilisée dans l'expression, puis 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, 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
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 cela ressemble à beaucoup d'autres langues, vous voudrez peut-être un essai simple:
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
La question a déjà reçu une réponse, mais permettez-moi d'ajouter aussi de mon côté.
Tout d'abord, ++ signifie incrémenter de un et -, décrémenter de un.
Maintenant, x ++ signifie Increment 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);
}
}
Cela donnera la sortie suivante:
x=19 a=17
x=19 b=19
x=18 a=19
x=17 b=17
D'accord, j'ai atterri ici car j'ai récemment rencontré le même problème lors de la vérification de l'implémentation classique de la pile. Juste un rappel que ceci est utilisé dans l'implémentation basée sur le tableau de Stack, qui est un peu plus rapide que celle avec liste liée.
Code ci-dessous, vérifiez la fonction Push and 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 ++ (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, par contre ++ 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);
}
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);
Avec i ++, cela s'appelle postincrement et la valeur est utilisée dans n'importe quel contexte incrémenté; ++ i is preincrement incrémente d'abord la valeur puis l'utilise en contexte.
Si vous ne l'utilisez pas dans n'importe quel contexte, peu importe ce que vous utilisez, mais postincrement est utilisé par convention.