Czy jest różnica między ++ x i x ++ w javie?
Czy jest różnica między ++ x i x ++ w javie?
Odpowiedzi:
tak
++ x zwiększa wartość x, a następnie zwraca x
x ++ zwraca wartość x, a następnie zwiększa
przykład:
x=0;
a=++x;
b=x++;
po uruchomieniu kodu a i b będą równe 1, ale x będzie równe 2.
Są one znane jako operatory przyrostków i przedrostków. Oba dodają 1 do zmiennej, ale istnieje różnica w wyniku instrukcji.
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
suffix
?
Tak,
int x=5;
System.out.println(++x);
wydrukuje 6
i
int x=5;
System.out.println(x++);
wydrukuje 5
.
Wylądowałem tutaj z jednego z jego ostatnich dupków i chociaż na to pytanie nie ma odpowiedzi, nie mogłem się powstrzymać od dekompilacji kodu i dodania „jeszcze jednej odpowiedzi” :-)
Aby być dokładnym (i prawdopodobnie nieco pedantycznym),
int y = 2;
y = y++;
jest wkompilowany w:
int y = 2;
int tmp = y;
y = y+1;
y = tmp;
Jeśli javac
ta Y.java
klasa:
public class Y {
public static void main(String []args) {
int y = 2;
y = y++;
}
}
i javap -c Y
otrzymujesz następujący kod jvm (pozwoliłem mi skomentować główną metodę za pomocą specyfikacji Java Virtual Machine Specification ):
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
}
Tak więc w końcu mamy:
0,1: y=2
2: tmp=y
3: y=y+1
6: y=tmp
Rozważając, co właściwie robi komputer ...
++ x: załaduj x z pamięci, zwiększ, użyj, zapisz z powrotem do pamięci.
x ++: załaduj x z pamięci, użyj, inkrementuj, zapisz z powrotem do pamięci.
Rozważ: a = 0 x = f (a ++) y = f (++ a)
gdzie funkcja f (p) zwraca p + 1
x będzie równe 1 (lub 2)
y będzie 2 (lub 1)
I w tym tkwi problem. Czy autor kompilatora przekazał parametr po pobraniu, po użyciu lub po zapisaniu.
Ogólnie rzecz biorąc, po prostu użyj x = x + 1. Jest to o wiele prostsze.
W Javie istnieje różnica między x ++ i ++ x
++ x jest postacią prefiksu: zwiększa wyrażenie zmiennej, a następnie używa nowej wartości w wyrażeniu.
Na przykład, jeśli jest używany w kodzie:
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 ++ jest postfiksem: wartość zmiennej jest najpierw używana w wyrażeniu, a następnie jest zwiększana po operacji.
Na przykład, jeśli jest używany w kodzie:
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'
Mam nadzieję, że to jest jasne. Uruchomienie i zabawa z powyższym kodem powinno pomóc w zrozumieniu.
Tak.
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);
}
}
Tak, zwracana wartość to odpowiednio wartość po i przed przyrostem.
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, wylądowałem tutaj, ponieważ ostatnio napotkałem ten sam problem podczas sprawdzania klasycznej implementacji stosu. Przypominam tylko, że jest to używane w implementacji stosu opartej na tablicach, która jest nieco szybsza niż w przypadku listy połączonej.
Kod poniżej, sprawdź funkcje push i 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;
}
}
Tak, jest różnica, w przypadku x ++ (postincrement), wartość x zostanie użyta w wyrażeniu, a x zostanie zwiększona o 1 po ocenie wyrażenia, z drugiej strony ++ x (preincrement), x + W wyrażeniu zostanie użyty 1. Brać przykład:
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);
}
Pytanie zostało już udzielone, ale pozwólcie, że dodam również z mojej strony.
Przede wszystkim ++ oznacza wzrost o jeden, a - oznacza zmniejszenie o jeden.
Teraz x ++ oznacza przyrost x po tej linii, a ++ x oznacza przyrost x przed tą linią.
Sprawdź ten przykład
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);
}
}
Da następujący wynik:
x=19 a=17
x=19 b=19
x=18 a=19
x=17 b=17
W przypadku i ++ nazywa się to postincrement, a wartość jest używana w jakimkolwiek kontekście następnie zwiększana; ++ i to preinkrementacja, która najpierw zwiększa wartość, a następnie używa jej w kontekście.
Jeśli nie używasz go w żadnym kontekście, nie ma znaczenia, czego używasz, ale postincrement jest używany zgodnie z konwencją.
Istnieje ogromna różnica.
Ponieważ większość odpowiedzi wskazywała już na teorię, chciałbym wskazać prosty przykład:
int x = 1;
//would print 1 as first statement will x = x and then x will increase
int x = x++;
System.out.println(x);
Teraz zobaczmy ++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);