wake-up-neo.net

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

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

93
erickreutz

++ x wird als Preincrement bezeichnet, während X ++ als Postincrement bezeichnet wird. 

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
261
Emil H

ja

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

beispiel:

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

nachdem der Code ausgeführt wurde, sind sowohl a als auch b 1, x jedoch 2.

60
Victor

Diese werden als Postfix- und Präfixoperatoren bezeichnet. Beide addieren die Variable um 1, aber das Ergebnis der Anweisung unterscheidet sich.

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
16
Pablojim

Ja,

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

druckt 6 und

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

wird 5 drucken.

11
Johannes Weiss

Ich bin hier von einem seiner letzten dup gelandet, und obwohl diese Frage mehr als beantwortet ist, konnte ich den Code nicht dekompilieren und "noch eine weitere Antwort" hinzufügen :-)

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

int y = 2;
y = y++;

ist kompiliert in:

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

Wenn Sie javac diese Y.Java-Klasse haben:

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

und javap -c Y erhalten Sie den folgenden Jvm-Code (ich habe mir erlaubt, die Hauptmethode mit Hilfe der Java Virtual Machine Specification zu kommentieren):

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 endlich:

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

Bei der Überlegung, was der Computer tatsächlich macht ...

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

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

Erwägen: a = 0 x = f (a ++) y = f (++ a)

wobei die Funktion f(p) p + 1 zurückgibt

x wird 1 (oder 2)

y wird 2 (oder 1)

Und darin liegt das Problem. Hat der Autor des Compilers den Parameter nach dem Abrufen, nach der Verwendung oder nach dem Speichern übergeben.

Im Allgemeinen verwenden Sie einfach x = x + 1. Es ist viel einfacher.

5
Cornell

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);
    }
}
3
Carl Manaster

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

++ x ist eine Präfixform: Er erhöht den Variablenausdruck und verwendet dann den neuen Wert im Ausdruck.

Zum Beispiel, wenn im Code verwendet:

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 ein Postfix-Formular: Der Variablenwert wird zuerst im Ausdruck verwendet und dann nach der Operation inkrementiert.

Zum Beispiel, wenn im Code verwendet:

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' 

Hoffe das ist klar. Das Laufen und Spielen mit dem obigen Code sollte zum besseren Verständnis beitragen.

3
Jeremy Levett

Ja, der zurückgegebene Wert ist der Wert nach bzw. 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
2
Lars Haugseth

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

Wenn also X = 9 ist, wird mit ++ X der Wert 10 verwendet, andernfalls der Wert 9.

2
nojevive

Wenn es wie viele andere Sprachen ist, möchten Sie vielleicht einen einfachen Versuch:

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

Wenn dies nicht der Fall ist, können sie gleichwertig sein

2
flq

Die Frage ist bereits beantwortet, aber ich darf auch von meiner Seite hinzufügen. 

Zuallererst ist ++ die Inkrementierung um eins und - um die Dekrementierung um eins.

Jetzt x ++ bedeutet Inkrement x nach dieser Zeile und ++ x bedeutet Inkrement x vor dieser Zeile.

Überprüfen Sie 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
1
Saif

OK, ich bin hier gelandet, weil ich kürzlich bei der Überprüfung der klassischen Stack-Implementierung auf das gleiche Problem gestoßen bin. Nur eine Erinnerung daran, dass dies in der Array-basierten Implementierung von Stack verwendet wird, die etwas schneller ist als die Liste mit verknüpften Listen.

Code unten, überprüfen Sie die Push & 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;
  }
}
1
kasaquan

Ja, es gibt einen Unterschied: Inase von x ++ (Nachinkrement), der Wert von x wird im Ausdruck verwendet und x wird nach der Auswertung des Ausdrucks um 1 erhöht, andererseits ++ x (Vorinkrement), x + 1 wird im Ausdruck verwendet. Nehmen Sie 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);  
}
1
Rohit Goyal

Es gibt einen großen Unterschied. 

Da die meisten Antworten bereits auf die Theorie hingewiesen haben, möchte ich auf 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);

Nun sehen wir ++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);
0
Pritam Banerjee

Bei i ++ heißt es postincrement und der Wert wird in jedem Kontext verwendet, der dann inkrementiert wird. ++ i ist vor dem Inkrementieren erhöht den Wert zuerst und verwendet ihn dann im Kontext. 

Wenn Sie es nicht in irgendeinem Kontext verwenden, ist es egal, was Sie verwenden, aber Postincrement wird von Konventionen verwendet. 

0
takra