Gibt es einen Unterschied zwischen x ++ und ++ x in Java?

Question

Gibt es einen Unterschied zwischen ++ x und x ++ in Java?

Answer 1

++ x heißt preincrement während x ++ postincrement genannt wird. Ja

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 

Answer 2

,

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

6 gedruckt wird und

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

wird 5 drucken.

Answer 3

ja

++ x erhöht den Wert von x und kehrt dann x
x ++ den Wert von x zurück und erhöht dann

Beispiel:

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

, nachdem der Code ausgeführt wird Sowohl a als auch b sind 1, aber x ist 2.

Answer 4

Ja, mit ++ X wird X + 1 im Ausdruck verwendet. Mit X ++ wird X im Ausdruck verwendet und X wird nur erhöht, nachdem der Ausdruck ausgewertet wurde.

Also, wenn X = 9, mit ++ X, der Wert 10 wird, sonst verwendet werden, wird der Wert 9.

Answer 5

Wenn es wie viele andere Sprachen ist können Sie einen einfachen Versuch haben wollen:

i = 0; 
if (0 == i++) // if true, increment happened after equality check 
if (2 == ++i) // if true, increment happened before equality check 

Wenn die oben nicht wie das passiert ist, kann sie gleichwertig sein

Answer 6

Ja.

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

Answer 7

Ja, der zurückgegebene Wert ist der Wert nach und vor der Inkrementierung.

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 

Answer 8

Diese werden als Postfix- und Präfixoperatoren bezeichnet. Beide addieren 1 zu der Variablen, aber es gibt einen Unterschied im Ergebnis der Anweisung.

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 

Answer 9

Ich landete hier von einem seiner letzten dup ‚s, und obwohl diese Frage mehr als beantwortet ist, kann ich nicht decompiling den Code helfen und das Hinzufügen von‚noch einem anderen Antwort‘:-)

Um genau zu sein (und wahrscheinlich ein bisschen pedantisch),

int y = 2; 
y = y++; 

zusammengestellt in:

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

Wenn Sie javac diese Y.java Klasse:

public class Y { 
    public static void main(String []args) { 
     int y = 2; 
     y = y++; 
    } 
} 

und javap -c Y, erhalten Sie das folgende JVM-Code (Ich habe mir erlaubt, die Hauptmethode mit Hilfe des Java Virtual Machine Specification Kommentar):

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 

} 

So , haben wir schließlich:

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

Answer 10

OK, ich hier gelandet, weil ich vor kurzem über die gleiche Frage kam, als Überprüfen der klassischen Stapelimplementierung. Nur eine Erinnerung, dass dies in der Array-basierten Implementierung von Stack verwendet wird, die etwas schneller ist als die Linked-List-Implementierung.

Code unten, überprüfen Sie die Push-und Pop-Funktion.

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

Answer 11

Ja, es gibt einen Unterschied, einhüllen von x ++ (Postinkrement) Wert von x wird im Ausdruck und x verwendet wird, um 1 nach dem Ausdruck erhöht wird ausgewertet wurde, auf der anderen Seite ++ x (Vorinkrement), x + 1 wird im Ausdruck verwendet. Nehmen wir ein Beispiel:

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

Answer 12

Die Frage ist schon beantwortet, aber lassen Sie mich auch von meiner Seite hinzuzufügen.

Zunächst einmal ++ bedeutet Zuwachs von einer und - Abnahme durch ein Mittel. Jetzt

x ++ bedeutet Increment x nach dieser Zeile und ++ x bedeutet Increment x vor dieser Zeile.

prüfen dieses Beispiel

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

Es wird die folgende Ausgabe geben:

x=19 a=17 
x=19 b=19 
x=18 a=19 
x=17 b=17 

Answer 13

Mit i ++, es Postinkrement genannt, und der Wert verwendet wird, in welchem ​​Zusammenhang dann erhöht; ++ i ist preincrement erhöht den Wert zuerst und verwendet ihn dann im Kontext.

Wenn Sie es in keinem Zusammenhang verwenden, ist es egal, was Sie verwenden, aber postincrement wird per Konvention verwendet.

Answer 14

Wenn man bedenkt, was der Computer tatsächlich tut ...

++ x: load x aus dem Speicher, erhöht, zu verwenden, um Speicher speichern zurück.

x ++: x aus dem Speicher laden, verwenden, inkrementieren, zurückspeichern.

Betrachten: a = 0 x = f (a ++) y = f (++ a)

wo Funktion f (p) wird 1 p + 1

x zurückgibt (oder 2)

y wird 2 (oder 1)

und darin liegt das Problem. Hat der Autor des Compilers den Parameter nach dem Abruf, nach der Verwendung oder nach der Speicherung übergeben?

Verwenden Sie im Allgemeinen einfach x = x + 1. Es ist viel einfacher.

Answer 15

Es gibt einen großen Unterschied.

Wie die meisten Antworten haben bereits die Theorie darauf hingewiesen, würde Ich mag ein einfaches Beispiel hinweisen:

int x = 1; 
//would print 1 as first statement will x = x and then x will increase 
int x = x++; 
System.out.println(x); 

Lassen Sie uns jetzt ++x sehen:

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

Answer 16

In Java gibt es ein Unterschied zwischen x ++ und ++ x

++ x ist ein Präfixformular: Es erhöht den Variablenausdruck und verwendet dann den neuen Wert im Ausdruck.

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 ++ ist eine Postfix-Form::

Zum Beispiel, wenn in Code verwendet Die Wertvariablen verwendet werden zuerst in dem Ausdruck und wird dann nach der Operation erhöht.

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' 

Hoffnung ist klar:

Zum Beispiel, wenn im Code verwendet. Das Ausführen und Spielen mit dem obigen Code sollte Ihnen beim Verständnis helfen.